#define TRACE
using System;
using System.Buffers;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using Google.Protobuf;
using Google.Protobuf.Collections;
using Google.Protobuf.Reflection;
using Google.Protobuf.WellKnownTypes;
using ICSharpCode.SharpZipLib.Core;
using ICSharpCode.SharpZipLib.GZip;
using ICSharpCode.SharpZipLib.Tar;
using Microsoft.CodeAnalysis;
using SkiaSharp;
using Tensorboard;
using TorchSharp.Modules;
using TorchSharp.PInvoke;
using TorchSharp.Utils;
using TorchSharp.Utils.tensorboard.Enums;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("TorchSharp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.106.0.0")]
[assembly: AssemblyInformationalVersion("0.106.0")]
[assembly: AssemblyProduct("TorchSharp")]
[assembly: AssemblyTitle("TorchSharp")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.106.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace Tensorboard
{
	public static class AllocationDescriptionReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static AllocationDescriptionReflection()
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CjV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vYWxsb2NhdGlvbl9kZXNjcmlw" + "dGlvbi5wcm90bxILdGVuc29yYm9hcmQiowEKFUFsbG9jYXRpb25EZXNjcmlw" + "dGlvbhIXCg9yZXF1ZXN0ZWRfYnl0ZXMYASABKAMSFwoPYWxsb2NhdGVkX2J5" + "dGVzGAIgASgDEhYKDmFsbG9jYXRvcl9uYW1lGAMgASgJEhUKDWFsbG9jYXRp" + "b25faWQYBCABKAMSHAoUaGFzX3NpbmdsZV9yZWZlcmVuY2UYBSABKAgSCwoD" + "cHRyGAYgASgEQpsBChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCG0FsbG9j" + "YXRpb25EZXNjcmlwdGlvblByb3Rvc1ABWl1naXRodWIuY29tL3RlbnNvcmZs" + "b3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dvL2NvcmUvZnJhbWV3b3JrL2Fs" + "bG9jYXRpb25fZGVzY3JpcHRpb25fZ29fcHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(AllocationDescription), (MessageParser)(object)AllocationDescription.Parser, new string[6] { "RequestedBytes", "AllocatedBytes", "AllocatorName", "AllocationId", "HasSingleReference", "Ptr" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class AllocationDescription : IMessage<AllocationDescription>, IMessage, IEquatable<AllocationDescription>, IDeepCloneable<AllocationDescription>
	{
		private static readonly MessageParser<AllocationDescription> _parser = new MessageParser<AllocationDescription>((Func<AllocationDescription>)(() => new AllocationDescription()));

		private UnknownFieldSet _unknownFields;

		public const int RequestedBytesFieldNumber = 1;

		private long requestedBytes_;

		public const int AllocatedBytesFieldNumber = 2;

		private long allocatedBytes_;

		public const int AllocatorNameFieldNumber = 3;

		private string allocatorName_ = "";

		public const int AllocationIdFieldNumber = 4;

		private long allocationId_;

		public const int HasSingleReferenceFieldNumber = 5;

		private bool hasSingleReference_;

		public const int PtrFieldNumber = 6;

		private ulong ptr_;

		[DebuggerNonUserCode]
		public static MessageParser<AllocationDescription> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => AllocationDescriptionReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long RequestedBytes
		{
			get
			{
				return requestedBytes_;
			}
			set
			{
				requestedBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllocatedBytes
		{
			get
			{
				return allocatedBytes_;
			}
			set
			{
				allocatedBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string AllocatorName
		{
			get
			{
				return allocatorName_;
			}
			set
			{
				allocatorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long AllocationId
		{
			get
			{
				return allocationId_;
			}
			set
			{
				allocationId_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool HasSingleReference
		{
			get
			{
				return hasSingleReference_;
			}
			set
			{
				hasSingleReference_ = value;
			}
		}

		[DebuggerNonUserCode]
		public ulong Ptr
		{
			get
			{
				return ptr_;
			}
			set
			{
				ptr_ = value;
			}
		}

		[DebuggerNonUserCode]
		public AllocationDescription()
		{
		}

		[DebuggerNonUserCode]
		public AllocationDescription(AllocationDescription other)
			: this()
		{
			requestedBytes_ = other.requestedBytes_;
			allocatedBytes_ = other.allocatedBytes_;
			allocatorName_ = other.allocatorName_;
			allocationId_ = other.allocationId_;
			hasSingleReference_ = other.hasSingleReference_;
			ptr_ = other.ptr_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public AllocationDescription Clone()
		{
			return new AllocationDescription(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as AllocationDescription);
		}

		[DebuggerNonUserCode]
		public bool Equals(AllocationDescription other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (RequestedBytes != other.RequestedBytes)
			{
				return false;
			}
			if (AllocatedBytes != other.AllocatedBytes)
			{
				return false;
			}
			if (AllocatorName != other.AllocatorName)
			{
				return false;
			}
			if (AllocationId != other.AllocationId)
			{
				return false;
			}
			if (HasSingleReference != other.HasSingleReference)
			{
				return false;
			}
			if (Ptr != other.Ptr)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (RequestedBytes != 0L)
			{
				num ^= RequestedBytes.GetHashCode();
			}
			if (AllocatedBytes != 0L)
			{
				num ^= AllocatedBytes.GetHashCode();
			}
			if (AllocatorName.Length != 0)
			{
				num ^= AllocatorName.GetHashCode();
			}
			if (AllocationId != 0L)
			{
				num ^= AllocationId.GetHashCode();
			}
			if (HasSingleReference)
			{
				num ^= HasSingleReference.GetHashCode();
			}
			if (Ptr != 0L)
			{
				num ^= Ptr.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (RequestedBytes != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(RequestedBytes);
			}
			if (AllocatedBytes != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(AllocatedBytes);
			}
			if (AllocatorName.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(AllocatorName);
			}
			if (AllocationId != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(AllocationId);
			}
			if (HasSingleReference)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(HasSingleReference);
			}
			if (Ptr != 0L)
			{
				output.WriteRawTag((byte)48);
				output.WriteUInt64(Ptr);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (RequestedBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(RequestedBytes);
			}
			if (AllocatedBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllocatedBytes);
			}
			if (AllocatorName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(AllocatorName);
			}
			if (AllocationId != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllocationId);
			}
			if (HasSingleReference)
			{
				num += 2;
			}
			if (Ptr != 0L)
			{
				num += 1 + CodedOutputStream.ComputeUInt64Size(Ptr);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(AllocationDescription other)
		{
			if (other != null)
			{
				if (other.RequestedBytes != 0L)
				{
					RequestedBytes = other.RequestedBytes;
				}
				if (other.AllocatedBytes != 0L)
				{
					AllocatedBytes = other.AllocatedBytes;
				}
				if (other.AllocatorName.Length != 0)
				{
					AllocatorName = other.AllocatorName;
				}
				if (other.AllocationId != 0L)
				{
					AllocationId = other.AllocationId;
				}
				if (other.HasSingleReference)
				{
					HasSingleReference = other.HasSingleReference;
				}
				if (other.Ptr != 0L)
				{
					Ptr = other.Ptr;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					RequestedBytes = input.ReadInt64();
					break;
				case 16u:
					AllocatedBytes = input.ReadInt64();
					break;
				case 26u:
					AllocatorName = input.ReadString();
					break;
				case 32u:
					AllocationId = input.ReadInt64();
					break;
				case 40u:
					HasSingleReference = input.ReadBool();
					break;
				case 48u:
					Ptr = input.ReadUInt64();
					break;
				}
			}
		}
	}
	public static class ApiDefReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static ApiDefReflection()
		{
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0245: Expected O, but got Unknown
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Expected O, but got Unknown
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiZ0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vYXBpX2RlZi5wcm90bxILdGVu" + "c29yYm9hcmQaKXRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9hdHRyX3ZhbHVl" + "LnByb3RvIucFCgZBcGlEZWYSFQoNZ3JhcGhfb3BfbmFtZRgBIAEoCRIbChNk" + "ZXByZWNhdGlvbl9tZXNzYWdlGAwgASgJEhsKE2RlcHJlY2F0aW9uX3ZlcnNp" + "b24YDSABKAUSMgoKdmlzaWJpbGl0eRgCIAEoDjIeLnRlbnNvcmJvYXJkLkFw" + "aURlZi5WaXNpYmlsaXR5Ei4KCGVuZHBvaW50GAMgAygLMhwudGVuc29yYm9h" + "cmQuQXBpRGVmLkVuZHBvaW50EicKBmluX2FyZxgEIAMoCzIXLnRlbnNvcmJv" + "YXJkLkFwaURlZi5BcmcSKAoHb3V0X2FyZxgFIAMoCzIXLnRlbnNvcmJvYXJk" + "LkFwaURlZi5BcmcSEQoJYXJnX29yZGVyGAsgAygJEiYKBGF0dHIYBiADKAsy" + "GC50ZW5zb3Jib2FyZC5BcGlEZWYuQXR0chIPCgdzdW1tYXJ5GAcgASgJEhMK" + "C2Rlc2NyaXB0aW9uGAggASgJEhoKEmRlc2NyaXB0aW9uX3ByZWZpeBgJIAEo" + "CRIaChJkZXNjcmlwdGlvbl9zdWZmaXgYCiABKAkaSQoIRW5kcG9pbnQSDAoE" + "bmFtZRgBIAEoCRISCgpkZXByZWNhdGVkGAMgASgIEhsKE2RlcHJlY2F0aW9u" + "X3ZlcnNpb24YBCABKAUaOwoDQXJnEgwKBG5hbWUYASABKAkSEQoJcmVuYW1l" + "X3RvGAIgASgJEhMKC2Rlc2NyaXB0aW9uGAMgASgJGmsKBEF0dHISDAoEbmFt" + "ZRgBIAEoCRIRCglyZW5hbWVfdG8YAiABKAkSLQoNZGVmYXVsdF92YWx1ZRgD" + "IAEoCzIWLnRlbnNvcmJvYXJkLkF0dHJWYWx1ZRITCgtkZXNjcmlwdGlvbhgE" + "IAEoCSJHCgpWaXNpYmlsaXR5EhYKEkRFRkFVTFRfVklTSUJJTElUWRAAEgsK" + "B1ZJU0lCTEUQARIICgRTS0lQEAISCgoGSElEREVOEAMiKgoHQXBpRGVmcxIf" + "CgJvcBgBIAMoCzITLnRlbnNvcmJvYXJkLkFwaURlZkJ9ChhvcmcudGVuc29y" + "Zmxvdy5mcmFtZXdvcmtCDEFwaURlZlByb3Rvc1ABWk5naXRodWIuY29tL3Rl" + "bnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dvL2NvcmUvZnJhbWV3" + "b3JrL2FwaV9kZWZfZ29fcHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[1] { AttrValueReflection.Descriptor }, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(ApiDef), (MessageParser)(object)ApiDef.Parser, new string[13]
				{
					"GraphOpName", "DeprecationMessage", "DeprecationVersion", "Visibility", "Endpoint", "InArg", "OutArg", "ArgOrder", "Attr", "Summary",
					"Description", "DescriptionPrefix", "DescriptionSuffix"
				}, (string[])null, new Type[1] { typeof(ApiDef.Types.Visibility) }, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[3]
				{
					new GeneratedClrTypeInfo(typeof(ApiDef.Types.Endpoint), (MessageParser)(object)ApiDef.Types.Endpoint.Parser, new string[3] { "Name", "Deprecated", "DeprecationVersion" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(ApiDef.Types.Arg), (MessageParser)(object)ApiDef.Types.Arg.Parser, new string[3] { "Name", "RenameTo", "Description" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(ApiDef.Types.Attr), (MessageParser)(object)ApiDef.Types.Attr.Parser, new string[4] { "Name", "RenameTo", "DefaultValue", "Description" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(ApiDefs), (MessageParser)(object)ApiDefs.Parser, new string[1] { "Op" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class ApiDef : IMessage<ApiDef>, IMessage, IEquatable<ApiDef>, IDeepCloneable<ApiDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum Visibility
			{
				[OriginalName("DEFAULT_VISIBILITY")]
				DefaultVisibility,
				[OriginalName("VISIBLE")]
				Visible,
				[OriginalName("SKIP")]
				Skip,
				[OriginalName("HIDDEN")]
				Hidden
			}

			public sealed class Endpoint : IMessage<Endpoint>, IMessage, IEquatable<Endpoint>, IDeepCloneable<Endpoint>
			{
				private static readonly MessageParser<Endpoint> _parser = new MessageParser<Endpoint>((Func<Endpoint>)(() => new Endpoint()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int DeprecatedFieldNumber = 3;

				private bool deprecated_;

				public const int DeprecationVersionFieldNumber = 4;

				private int deprecationVersion_;

				[DebuggerNonUserCode]
				public static MessageParser<Endpoint> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => ApiDef.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public bool Deprecated
				{
					get
					{
						return deprecated_;
					}
					set
					{
						deprecated_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int DeprecationVersion
				{
					get
					{
						return deprecationVersion_;
					}
					set
					{
						deprecationVersion_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Endpoint()
				{
				}

				[DebuggerNonUserCode]
				public Endpoint(Endpoint other)
					: this()
				{
					name_ = other.name_;
					deprecated_ = other.deprecated_;
					deprecationVersion_ = other.deprecationVersion_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Endpoint Clone()
				{
					return new Endpoint(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Endpoint);
				}

				[DebuggerNonUserCode]
				public bool Equals(Endpoint other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (Deprecated != other.Deprecated)
					{
						return false;
					}
					if (DeprecationVersion != other.DeprecationVersion)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (Deprecated)
					{
						num ^= Deprecated.GetHashCode();
					}
					if (DeprecationVersion != 0)
					{
						num ^= DeprecationVersion.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					if (Deprecated)
					{
						output.WriteRawTag((byte)24);
						output.WriteBool(Deprecated);
					}
					if (DeprecationVersion != 0)
					{
						output.WriteRawTag((byte)32);
						output.WriteInt32(DeprecationVersion);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (Deprecated)
					{
						num += 2;
					}
					if (DeprecationVersion != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(DeprecationVersion);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Endpoint other)
				{
					if (other != null)
					{
						if (other.Name.Length != 0)
						{
							Name = other.Name;
						}
						if (other.Deprecated)
						{
							Deprecated = other.Deprecated;
						}
						if (other.DeprecationVersion != 0)
						{
							DeprecationVersion = other.DeprecationVersion;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 24u:
							Deprecated = input.ReadBool();
							break;
						case 32u:
							DeprecationVersion = input.ReadInt32();
							break;
						}
					}
				}
			}

			public sealed class Arg : IMessage<Arg>, IMessage, IEquatable<Arg>, IDeepCloneable<Arg>
			{
				private static readonly MessageParser<Arg> _parser = new MessageParser<Arg>((Func<Arg>)(() => new Arg()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int RenameToFieldNumber = 2;

				private string renameTo_ = "";

				public const int DescriptionFieldNumber = 3;

				private string description_ = "";

				[DebuggerNonUserCode]
				public static MessageParser<Arg> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => ApiDef.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string RenameTo
				{
					get
					{
						return renameTo_;
					}
					set
					{
						renameTo_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string Description
				{
					get
					{
						return description_;
					}
					set
					{
						description_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public Arg()
				{
				}

				[DebuggerNonUserCode]
				public Arg(Arg other)
					: this()
				{
					name_ = other.name_;
					renameTo_ = other.renameTo_;
					description_ = other.description_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Arg Clone()
				{
					return new Arg(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Arg);
				}

				[DebuggerNonUserCode]
				public bool Equals(Arg other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (RenameTo != other.RenameTo)
					{
						return false;
					}
					if (Description != other.Description)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (RenameTo.Length != 0)
					{
						num ^= RenameTo.GetHashCode();
					}
					if (Description.Length != 0)
					{
						num ^= Description.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					if (RenameTo.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(RenameTo);
					}
					if (Description.Length != 0)
					{
						output.WriteRawTag((byte)26);
						output.WriteString(Description);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (RenameTo.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(RenameTo);
					}
					if (Description.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Description);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Arg other)
				{
					if (other != null)
					{
						if (other.Name.Length != 0)
						{
							Name = other.Name;
						}
						if (other.RenameTo.Length != 0)
						{
							RenameTo = other.RenameTo;
						}
						if (other.Description.Length != 0)
						{
							Description = other.Description;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 18u:
							RenameTo = input.ReadString();
							break;
						case 26u:
							Description = input.ReadString();
							break;
						}
					}
				}
			}

			public sealed class Attr : IMessage<Attr>, IMessage, IEquatable<Attr>, IDeepCloneable<Attr>
			{
				private static readonly MessageParser<Attr> _parser = new MessageParser<Attr>((Func<Attr>)(() => new Attr()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int RenameToFieldNumber = 2;

				private string renameTo_ = "";

				public const int DefaultValueFieldNumber = 3;

				private AttrValue defaultValue_;

				public const int DescriptionFieldNumber = 4;

				private string description_ = "";

				[DebuggerNonUserCode]
				public static MessageParser<Attr> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => ApiDef.Descriptor.NestedTypes[2];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string RenameTo
				{
					get
					{
						return renameTo_;
					}
					set
					{
						renameTo_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public AttrValue DefaultValue
				{
					get
					{
						return defaultValue_;
					}
					set
					{
						defaultValue_ = value;
					}
				}

				[DebuggerNonUserCode]
				public string Description
				{
					get
					{
						return description_;
					}
					set
					{
						description_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public Attr()
				{
				}

				[DebuggerNonUserCode]
				public Attr(Attr other)
					: this()
				{
					name_ = other.name_;
					renameTo_ = other.renameTo_;
					defaultValue_ = ((other.defaultValue_ != null) ? other.defaultValue_.Clone() : null);
					description_ = other.description_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Attr Clone()
				{
					return new Attr(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Attr);
				}

				[DebuggerNonUserCode]
				public bool Equals(Attr other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (RenameTo != other.RenameTo)
					{
						return false;
					}
					if (!object.Equals(DefaultValue, other.DefaultValue))
					{
						return false;
					}
					if (Description != other.Description)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (RenameTo.Length != 0)
					{
						num ^= RenameTo.GetHashCode();
					}
					if (defaultValue_ != null)
					{
						num ^= DefaultValue.GetHashCode();
					}
					if (Description.Length != 0)
					{
						num ^= Description.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					if (RenameTo.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(RenameTo);
					}
					if (defaultValue_ != null)
					{
						output.WriteRawTag((byte)26);
						output.WriteMessage((IMessage)(object)DefaultValue);
					}
					if (Description.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteString(Description);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (RenameTo.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(RenameTo);
					}
					if (defaultValue_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)DefaultValue);
					}
					if (Description.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Description);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Attr other)
				{
					if (other == null)
					{
						return;
					}
					if (other.Name.Length != 0)
					{
						Name = other.Name;
					}
					if (other.RenameTo.Length != 0)
					{
						RenameTo = other.RenameTo;
					}
					if (other.defaultValue_ != null)
					{
						if (defaultValue_ == null)
						{
							DefaultValue = new AttrValue();
						}
						DefaultValue.MergeFrom(other.DefaultValue);
					}
					if (other.Description.Length != 0)
					{
						Description = other.Description;
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 18u:
							RenameTo = input.ReadString();
							break;
						case 26u:
							if (defaultValue_ == null)
							{
								DefaultValue = new AttrValue();
							}
							input.ReadMessage((IMessage)(object)DefaultValue);
							break;
						case 34u:
							Description = input.ReadString();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<ApiDef> _parser = new MessageParser<ApiDef>((Func<ApiDef>)(() => new ApiDef()));

		private UnknownFieldSet _unknownFields;

		public const int GraphOpNameFieldNumber = 1;

		private string graphOpName_ = "";

		public const int DeprecationMessageFieldNumber = 12;

		private string deprecationMessage_ = "";

		public const int DeprecationVersionFieldNumber = 13;

		private int deprecationVersion_;

		public const int VisibilityFieldNumber = 2;

		private Types.Visibility visibility_;

		public const int EndpointFieldNumber = 3;

		private static readonly FieldCodec<Types.Endpoint> _repeated_endpoint_codec = FieldCodec.ForMessage<Types.Endpoint>(26u, Types.Endpoint.Parser);

		private readonly RepeatedField<Types.Endpoint> endpoint_ = new RepeatedField<Types.Endpoint>();

		public const int InArgFieldNumber = 4;

		private static readonly FieldCodec<Types.Arg> _repeated_inArg_codec = FieldCodec.ForMessage<Types.Arg>(34u, Types.Arg.Parser);

		private readonly RepeatedField<Types.Arg> inArg_ = new RepeatedField<Types.Arg>();

		public const int OutArgFieldNumber = 5;

		private static readonly FieldCodec<Types.Arg> _repeated_outArg_codec = FieldCodec.ForMessage<Types.Arg>(42u, Types.Arg.Parser);

		private readonly RepeatedField<Types.Arg> outArg_ = new RepeatedField<Types.Arg>();

		public const int ArgOrderFieldNumber = 11;

		private static readonly FieldCodec<string> _repeated_argOrder_codec = FieldCodec.ForString(90u);

		private readonly RepeatedField<string> argOrder_ = new RepeatedField<string>();

		public const int AttrFieldNumber = 6;

		private static readonly FieldCodec<Types.Attr> _repeated_attr_codec = FieldCodec.ForMessage<Types.Attr>(50u, Types.Attr.Parser);

		private readonly RepeatedField<Types.Attr> attr_ = new RepeatedField<Types.Attr>();

		public const int SummaryFieldNumber = 7;

		private string summary_ = "";

		public const int DescriptionFieldNumber = 8;

		private string description_ = "";

		public const int DescriptionPrefixFieldNumber = 9;

		private string descriptionPrefix_ = "";

		public const int DescriptionSuffixFieldNumber = 10;

		private string descriptionSuffix_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<ApiDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ApiDefReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string GraphOpName
		{
			get
			{
				return graphOpName_;
			}
			set
			{
				graphOpName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string DeprecationMessage
		{
			get
			{
				return deprecationMessage_;
			}
			set
			{
				deprecationMessage_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public int DeprecationVersion
		{
			get
			{
				return deprecationVersion_;
			}
			set
			{
				deprecationVersion_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Visibility Visibility
		{
			get
			{
				return visibility_;
			}
			set
			{
				visibility_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<Types.Endpoint> Endpoint => endpoint_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Arg> InArg => inArg_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Arg> OutArg => outArg_;

		[DebuggerNonUserCode]
		public RepeatedField<string> ArgOrder => argOrder_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Attr> Attr => attr_;

		[DebuggerNonUserCode]
		public string Summary
		{
			get
			{
				return summary_;
			}
			set
			{
				summary_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Description
		{
			get
			{
				return description_;
			}
			set
			{
				description_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string DescriptionPrefix
		{
			get
			{
				return descriptionPrefix_;
			}
			set
			{
				descriptionPrefix_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string DescriptionSuffix
		{
			get
			{
				return descriptionSuffix_;
			}
			set
			{
				descriptionSuffix_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public ApiDef()
		{
		}

		[DebuggerNonUserCode]
		public ApiDef(ApiDef other)
			: this()
		{
			graphOpName_ = other.graphOpName_;
			deprecationMessage_ = other.deprecationMessage_;
			deprecationVersion_ = other.deprecationVersion_;
			visibility_ = other.visibility_;
			endpoint_ = other.endpoint_.Clone();
			inArg_ = other.inArg_.Clone();
			outArg_ = other.outArg_.Clone();
			argOrder_ = other.argOrder_.Clone();
			attr_ = other.attr_.Clone();
			summary_ = other.summary_;
			description_ = other.description_;
			descriptionPrefix_ = other.descriptionPrefix_;
			descriptionSuffix_ = other.descriptionSuffix_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ApiDef Clone()
		{
			return new ApiDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ApiDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(ApiDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (GraphOpName != other.GraphOpName)
			{
				return false;
			}
			if (DeprecationMessage != other.DeprecationMessage)
			{
				return false;
			}
			if (DeprecationVersion != other.DeprecationVersion)
			{
				return false;
			}
			if (Visibility != other.Visibility)
			{
				return false;
			}
			if (!endpoint_.Equals(other.endpoint_))
			{
				return false;
			}
			if (!inArg_.Equals(other.inArg_))
			{
				return false;
			}
			if (!outArg_.Equals(other.outArg_))
			{
				return false;
			}
			if (!argOrder_.Equals(other.argOrder_))
			{
				return false;
			}
			if (!attr_.Equals(other.attr_))
			{
				return false;
			}
			if (Summary != other.Summary)
			{
				return false;
			}
			if (Description != other.Description)
			{
				return false;
			}
			if (DescriptionPrefix != other.DescriptionPrefix)
			{
				return false;
			}
			if (DescriptionSuffix != other.DescriptionSuffix)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (GraphOpName.Length != 0)
			{
				num ^= GraphOpName.GetHashCode();
			}
			if (DeprecationMessage.Length != 0)
			{
				num ^= DeprecationMessage.GetHashCode();
			}
			if (DeprecationVersion != 0)
			{
				num ^= DeprecationVersion.GetHashCode();
			}
			if (Visibility != Types.Visibility.DefaultVisibility)
			{
				num ^= Visibility.GetHashCode();
			}
			num ^= ((object)endpoint_).GetHashCode();
			num ^= ((object)inArg_).GetHashCode();
			num ^= ((object)outArg_).GetHashCode();
			num ^= ((object)argOrder_).GetHashCode();
			num ^= ((object)attr_).GetHashCode();
			if (Summary.Length != 0)
			{
				num ^= Summary.GetHashCode();
			}
			if (Description.Length != 0)
			{
				num ^= Description.GetHashCode();
			}
			if (DescriptionPrefix.Length != 0)
			{
				num ^= DescriptionPrefix.GetHashCode();
			}
			if (DescriptionSuffix.Length != 0)
			{
				num ^= DescriptionSuffix.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (GraphOpName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(GraphOpName);
			}
			if (Visibility != Types.Visibility.DefaultVisibility)
			{
				output.WriteRawTag((byte)16);
				output.WriteEnum((int)Visibility);
			}
			endpoint_.WriteTo(output, _repeated_endpoint_codec);
			inArg_.WriteTo(output, _repeated_inArg_codec);
			outArg_.WriteTo(output, _repeated_outArg_codec);
			attr_.WriteTo(output, _repeated_attr_codec);
			if (Summary.Length != 0)
			{
				output.WriteRawTag((byte)58);
				output.WriteString(Summary);
			}
			if (Description.Length != 0)
			{
				output.WriteRawTag((byte)66);
				output.WriteString(Description);
			}
			if (DescriptionPrefix.Length != 0)
			{
				output.WriteRawTag((byte)74);
				output.WriteString(DescriptionPrefix);
			}
			if (DescriptionSuffix.Length != 0)
			{
				output.WriteRawTag((byte)82);
				output.WriteString(DescriptionSuffix);
			}
			argOrder_.WriteTo(output, _repeated_argOrder_codec);
			if (DeprecationMessage.Length != 0)
			{
				output.WriteRawTag((byte)98);
				output.WriteString(DeprecationMessage);
			}
			if (DeprecationVersion != 0)
			{
				output.WriteRawTag((byte)104);
				output.WriteInt32(DeprecationVersion);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (GraphOpName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(GraphOpName);
			}
			if (DeprecationMessage.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(DeprecationMessage);
			}
			if (DeprecationVersion != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(DeprecationVersion);
			}
			if (Visibility != Types.Visibility.DefaultVisibility)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Visibility);
			}
			num += endpoint_.CalculateSize(_repeated_endpoint_codec);
			num += inArg_.CalculateSize(_repeated_inArg_codec);
			num += outArg_.CalculateSize(_repeated_outArg_codec);
			num += argOrder_.CalculateSize(_repeated_argOrder_codec);
			num += attr_.CalculateSize(_repeated_attr_codec);
			if (Summary.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Summary);
			}
			if (Description.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Description);
			}
			if (DescriptionPrefix.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(DescriptionPrefix);
			}
			if (DescriptionSuffix.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(DescriptionSuffix);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ApiDef other)
		{
			if (other != null)
			{
				if (other.GraphOpName.Length != 0)
				{
					GraphOpName = other.GraphOpName;
				}
				if (other.DeprecationMessage.Length != 0)
				{
					DeprecationMessage = other.DeprecationMessage;
				}
				if (other.DeprecationVersion != 0)
				{
					DeprecationVersion = other.DeprecationVersion;
				}
				if (other.Visibility != Types.Visibility.DefaultVisibility)
				{
					Visibility = other.Visibility;
				}
				endpoint_.Add((IEnumerable<Types.Endpoint>)other.endpoint_);
				inArg_.Add((IEnumerable<Types.Arg>)other.inArg_);
				outArg_.Add((IEnumerable<Types.Arg>)other.outArg_);
				argOrder_.Add((IEnumerable<string>)other.argOrder_);
				attr_.Add((IEnumerable<Types.Attr>)other.attr_);
				if (other.Summary.Length != 0)
				{
					Summary = other.Summary;
				}
				if (other.Description.Length != 0)
				{
					Description = other.Description;
				}
				if (other.DescriptionPrefix.Length != 0)
				{
					DescriptionPrefix = other.DescriptionPrefix;
				}
				if (other.DescriptionSuffix.Length != 0)
				{
					DescriptionSuffix = other.DescriptionSuffix;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					GraphOpName = input.ReadString();
					break;
				case 16u:
					Visibility = (Types.Visibility)input.ReadEnum();
					break;
				case 26u:
					endpoint_.AddEntriesFrom(input, _repeated_endpoint_codec);
					break;
				case 34u:
					inArg_.AddEntriesFrom(input, _repeated_inArg_codec);
					break;
				case 42u:
					outArg_.AddEntriesFrom(input, _repeated_outArg_codec);
					break;
				case 50u:
					attr_.AddEntriesFrom(input, _repeated_attr_codec);
					break;
				case 58u:
					Summary = input.ReadString();
					break;
				case 66u:
					Description = input.ReadString();
					break;
				case 74u:
					DescriptionPrefix = input.ReadString();
					break;
				case 82u:
					DescriptionSuffix = input.ReadString();
					break;
				case 90u:
					argOrder_.AddEntriesFrom(input, _repeated_argOrder_codec);
					break;
				case 98u:
					DeprecationMessage = input.ReadString();
					break;
				case 104u:
					DeprecationVersion = input.ReadInt32();
					break;
				}
			}
		}
	}
	public sealed class ApiDefs : IMessage<ApiDefs>, IMessage, IEquatable<ApiDefs>, IDeepCloneable<ApiDefs>
	{
		private static readonly MessageParser<ApiDefs> _parser = new MessageParser<ApiDefs>((Func<ApiDefs>)(() => new ApiDefs()));

		private UnknownFieldSet _unknownFields;

		public const int OpFieldNumber = 1;

		private static readonly FieldCodec<ApiDef> _repeated_op_codec = FieldCodec.ForMessage<ApiDef>(10u, ApiDef.Parser);

		private readonly RepeatedField<ApiDef> op_ = new RepeatedField<ApiDef>();

		[DebuggerNonUserCode]
		public static MessageParser<ApiDefs> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ApiDefReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<ApiDef> Op => op_;

		[DebuggerNonUserCode]
		public ApiDefs()
		{
		}

		[DebuggerNonUserCode]
		public ApiDefs(ApiDefs other)
			: this()
		{
			op_ = other.op_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ApiDefs Clone()
		{
			return new ApiDefs(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ApiDefs);
		}

		[DebuggerNonUserCode]
		public bool Equals(ApiDefs other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!op_.Equals(other.op_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)op_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			op_.WriteTo(output, _repeated_op_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += op_.CalculateSize(_repeated_op_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ApiDefs other)
		{
			if (other != null)
			{
				op_.Add((IEnumerable<ApiDef>)other.op_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					op_.AddEntriesFrom(input, _repeated_op_codec);
				}
			}
		}
	}
	public static class AttrValueReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static AttrValueReflection()
		{
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dd: Expected O, but got Unknown
			//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vYXR0cl92YWx1ZS5wcm90bxIL" + "dGVuc29yYm9hcmQaJXRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90ZW5zb3Iu" + "cHJvdG8aK3RlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90ZW5zb3Jfc2hhcGUu" + "cHJvdG8aJHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90eXBlcy5wcm90byKv" + "BAoJQXR0clZhbHVlEgsKAXMYAiABKAxIABILCgFpGAMgASgDSAASCwoBZhgE" + "IAEoAkgAEgsKAWIYBSABKAhIABIlCgR0eXBlGAYgASgOMhUudGVuc29yYm9h" + "cmQuRGF0YVR5cGVIABIuCgVzaGFwZRgHIAEoCzIdLnRlbnNvcmJvYXJkLlRl" + "bnNvclNoYXBlUHJvdG9IABIqCgZ0ZW5zb3IYCCABKAsyGC50ZW5zb3Jib2Fy" + "ZC5UZW5zb3JQcm90b0gAEjAKBGxpc3QYASABKAsyIC50ZW5zb3Jib2FyZC5B" + "dHRyVmFsdWUuTGlzdFZhbHVlSAASKQoEZnVuYxgKIAEoCzIZLnRlbnNvcmJv" + "YXJkLk5hbWVBdHRyTGlzdEgAEhUKC3BsYWNlaG9sZGVyGAkgASgJSAAa7QEK" + "CUxpc3RWYWx1ZRIJCgFzGAIgAygMEg0KAWkYAyADKANCAhABEg0KAWYYBCAD" + "KAJCAhABEg0KAWIYBSADKAhCAhABEicKBHR5cGUYBiADKA4yFS50ZW5zb3Ji" + "b2FyZC5EYXRhVHlwZUICEAESLAoFc2hhcGUYByADKAsyHS50ZW5zb3Jib2Fy" + "ZC5UZW5zb3JTaGFwZVByb3RvEigKBnRlbnNvchgIIAMoCzIYLnRlbnNvcmJv" + "YXJkLlRlbnNvclByb3RvEicKBGZ1bmMYCSADKAsyGS50ZW5zb3Jib2FyZC5O" + "YW1lQXR0ckxpc3RCBwoFdmFsdWUilAEKDE5hbWVBdHRyTGlzdBIMCgRuYW1l" + "GAEgASgJEjEKBGF0dHIYAiADKAsyIy50ZW5zb3Jib2FyZC5OYW1lQXR0ckxp" + "c3QuQXR0ckVudHJ5GkMKCUF0dHJFbnRyeRILCgNrZXkYASABKAkSJQoFdmFs" + "dWUYAiABKAsyFi50ZW5zb3Jib2FyZC5BdHRyVmFsdWU6AjgBQoMBChhvcmcu" + "dGVuc29yZmxvdy5mcmFtZXdvcmtCD0F0dHJWYWx1ZVByb3Rvc1ABWlFnaXRo" + "dWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dvL2Nv" + "cmUvZnJhbWV3b3JrL2F0dHJfdmFsdWVfZ29fcHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				TensorReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(AttrValue), (MessageParser)(object)AttrValue.Parser, new string[10] { "S", "I", "F", "B", "Type", "Shape", "Tensor", "List", "Func", "Placeholder" }, new string[1] { "Value" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(AttrValue.Types.ListValue), (MessageParser)(object)AttrValue.Types.ListValue.Parser, new string[8] { "S", "I", "F", "B", "Type", "Shape", "Tensor", "Func" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(NameAttrList), (MessageParser)(object)NameAttrList.Parser, new string[2] { "Name", "Attr" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1])
			}));
		}
	}
	public sealed class AttrValue : IMessage<AttrValue>, IMessage, IEquatable<AttrValue>, IDeepCloneable<AttrValue>
	{
		public enum ValueOneofCase
		{
			None = 0,
			S = 2,
			I = 3,
			F = 4,
			B = 5,
			Type = 6,
			Shape = 7,
			Tensor = 8,
			List = 1,
			Func = 10,
			Placeholder = 9
		}

		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class ListValue : IMessage<ListValue>, IMessage, IEquatable<ListValue>, IDeepCloneable<ListValue>
			{
				private static readonly MessageParser<ListValue> _parser = new MessageParser<ListValue>((Func<ListValue>)(() => new ListValue()));

				private UnknownFieldSet _unknownFields;

				public const int SFieldNumber = 2;

				private static readonly FieldCodec<ByteString> _repeated_s_codec = FieldCodec.ForBytes(18u);

				private readonly RepeatedField<ByteString> s_ = new RepeatedField<ByteString>();

				public const int IFieldNumber = 3;

				private static readonly FieldCodec<long> _repeated_i_codec = FieldCodec.ForInt64(26u);

				private readonly RepeatedField<long> i_ = new RepeatedField<long>();

				public const int FFieldNumber = 4;

				private static readonly FieldCodec<float> _repeated_f_codec = FieldCodec.ForFloat(34u);

				private readonly RepeatedField<float> f_ = new RepeatedField<float>();

				public const int BFieldNumber = 5;

				private static readonly FieldCodec<bool> _repeated_b_codec = FieldCodec.ForBool(42u);

				private readonly RepeatedField<bool> b_ = new RepeatedField<bool>();

				public const int TypeFieldNumber = 6;

				private static readonly FieldCodec<DataType> _repeated_type_codec = FieldCodec.ForEnum<DataType>(50u, (Func<DataType, int>)((DataType x) => (int)x), (Func<int, DataType>)((int x) => (DataType)x));

				private readonly RepeatedField<DataType> type_ = new RepeatedField<DataType>();

				public const int ShapeFieldNumber = 7;

				private static readonly FieldCodec<TensorShapeProto> _repeated_shape_codec = FieldCodec.ForMessage<TensorShapeProto>(58u, TensorShapeProto.Parser);

				private readonly RepeatedField<TensorShapeProto> shape_ = new RepeatedField<TensorShapeProto>();

				public const int TensorFieldNumber = 8;

				private static readonly FieldCodec<TensorProto> _repeated_tensor_codec = FieldCodec.ForMessage<TensorProto>(66u, TensorProto.Parser);

				private readonly RepeatedField<TensorProto> tensor_ = new RepeatedField<TensorProto>();

				public const int FuncFieldNumber = 9;

				private static readonly FieldCodec<NameAttrList> _repeated_func_codec = FieldCodec.ForMessage<NameAttrList>(74u, NameAttrList.Parser);

				private readonly RepeatedField<NameAttrList> func_ = new RepeatedField<NameAttrList>();

				[DebuggerNonUserCode]
				public static MessageParser<ListValue> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => AttrValue.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<ByteString> S => s_;

				[DebuggerNonUserCode]
				public RepeatedField<long> I => i_;

				[DebuggerNonUserCode]
				public RepeatedField<float> F => f_;

				[DebuggerNonUserCode]
				public RepeatedField<bool> B => b_;

				[DebuggerNonUserCode]
				public RepeatedField<DataType> Type => type_;

				[DebuggerNonUserCode]
				public RepeatedField<TensorShapeProto> Shape => shape_;

				[DebuggerNonUserCode]
				public RepeatedField<TensorProto> Tensor => tensor_;

				[DebuggerNonUserCode]
				public RepeatedField<NameAttrList> Func => func_;

				[DebuggerNonUserCode]
				public ListValue()
				{
				}

				[DebuggerNonUserCode]
				public ListValue(ListValue other)
					: this()
				{
					s_ = other.s_.Clone();
					i_ = other.i_.Clone();
					f_ = other.f_.Clone();
					b_ = other.b_.Clone();
					type_ = other.type_.Clone();
					shape_ = other.shape_.Clone();
					tensor_ = other.tensor_.Clone();
					func_ = other.func_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public ListValue Clone()
				{
					return new ListValue(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as ListValue);
				}

				[DebuggerNonUserCode]
				public bool Equals(ListValue other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!s_.Equals(other.s_))
					{
						return false;
					}
					if (!i_.Equals(other.i_))
					{
						return false;
					}
					if (!f_.Equals(other.f_))
					{
						return false;
					}
					if (!b_.Equals(other.b_))
					{
						return false;
					}
					if (!type_.Equals(other.type_))
					{
						return false;
					}
					if (!shape_.Equals(other.shape_))
					{
						return false;
					}
					if (!tensor_.Equals(other.tensor_))
					{
						return false;
					}
					if (!func_.Equals(other.func_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)s_).GetHashCode();
					num ^= ((object)i_).GetHashCode();
					num ^= ((object)f_).GetHashCode();
					num ^= ((object)b_).GetHashCode();
					num ^= ((object)type_).GetHashCode();
					num ^= ((object)shape_).GetHashCode();
					num ^= ((object)tensor_).GetHashCode();
					num ^= ((object)func_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					s_.WriteTo(output, _repeated_s_codec);
					i_.WriteTo(output, _repeated_i_codec);
					f_.WriteTo(output, _repeated_f_codec);
					b_.WriteTo(output, _repeated_b_codec);
					type_.WriteTo(output, _repeated_type_codec);
					shape_.WriteTo(output, _repeated_shape_codec);
					tensor_.WriteTo(output, _repeated_tensor_codec);
					func_.WriteTo(output, _repeated_func_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += s_.CalculateSize(_repeated_s_codec);
					num += i_.CalculateSize(_repeated_i_codec);
					num += f_.CalculateSize(_repeated_f_codec);
					num += b_.CalculateSize(_repeated_b_codec);
					num += type_.CalculateSize(_repeated_type_codec);
					num += shape_.CalculateSize(_repeated_shape_codec);
					num += tensor_.CalculateSize(_repeated_tensor_codec);
					num += func_.CalculateSize(_repeated_func_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(ListValue other)
				{
					if (other != null)
					{
						s_.Add((IEnumerable<ByteString>)other.s_);
						i_.Add((IEnumerable<long>)other.i_);
						f_.Add((IEnumerable<float>)other.f_);
						b_.Add((IEnumerable<bool>)other.b_);
						type_.Add((IEnumerable<DataType>)other.type_);
						shape_.Add((IEnumerable<TensorShapeProto>)other.shape_);
						tensor_.Add((IEnumerable<TensorProto>)other.tensor_);
						func_.Add((IEnumerable<NameAttrList>)other.func_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 18u:
							s_.AddEntriesFrom(input, _repeated_s_codec);
							break;
						case 24u:
						case 26u:
							i_.AddEntriesFrom(input, _repeated_i_codec);
							break;
						case 34u:
						case 37u:
							f_.AddEntriesFrom(input, _repeated_f_codec);
							break;
						case 40u:
						case 42u:
							b_.AddEntriesFrom(input, _repeated_b_codec);
							break;
						case 48u:
						case 50u:
							type_.AddEntriesFrom(input, _repeated_type_codec);
							break;
						case 58u:
							shape_.AddEntriesFrom(input, _repeated_shape_codec);
							break;
						case 66u:
							tensor_.AddEntriesFrom(input, _repeated_tensor_codec);
							break;
						case 74u:
							func_.AddEntriesFrom(input, _repeated_func_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<AttrValue> _parser = new MessageParser<AttrValue>((Func<AttrValue>)(() => new AttrValue()));

		private UnknownFieldSet _unknownFields;

		public const int SFieldNumber = 2;

		public const int IFieldNumber = 3;

		public const int FFieldNumber = 4;

		public const int BFieldNumber = 5;

		public const int TypeFieldNumber = 6;

		public const int ShapeFieldNumber = 7;

		public const int TensorFieldNumber = 8;

		public const int ListFieldNumber = 1;

		public const int FuncFieldNumber = 10;

		public const int PlaceholderFieldNumber = 9;

		private object value_;

		private ValueOneofCase valueCase_;

		[DebuggerNonUserCode]
		public static MessageParser<AttrValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => AttrValueReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public ByteString S
		{
			get
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				if (valueCase_ != ValueOneofCase.S)
				{
					return ByteString.Empty;
				}
				return (ByteString)value_;
			}
			set
			{
				value_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
				valueCase_ = ValueOneofCase.S;
			}
		}

		[DebuggerNonUserCode]
		public long I
		{
			get
			{
				if (valueCase_ != ValueOneofCase.I)
				{
					return 0L;
				}
				return (long)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ValueOneofCase.I;
			}
		}

		[DebuggerNonUserCode]
		public float F
		{
			get
			{
				if (valueCase_ != ValueOneofCase.F)
				{
					return 0f;
				}
				return (float)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ValueOneofCase.F;
			}
		}

		[DebuggerNonUserCode]
		public bool B
		{
			get
			{
				if (valueCase_ != ValueOneofCase.B)
				{
					return false;
				}
				return (bool)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ValueOneofCase.B;
			}
		}

		[DebuggerNonUserCode]
		public DataType Type
		{
			get
			{
				if (valueCase_ != ValueOneofCase.Type)
				{
					return DataType.DtInvalid;
				}
				return (DataType)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ValueOneofCase.Type;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto Shape
		{
			get
			{
				if (valueCase_ != ValueOneofCase.Shape)
				{
					return null;
				}
				return (TensorShapeProto)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ((value != null) ? ValueOneofCase.Shape : ValueOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public TensorProto Tensor
		{
			get
			{
				if (valueCase_ != ValueOneofCase.Tensor)
				{
					return null;
				}
				return (TensorProto)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ((value != null) ? ValueOneofCase.Tensor : ValueOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public Types.ListValue List
		{
			get
			{
				if (valueCase_ != ValueOneofCase.List)
				{
					return null;
				}
				return (Types.ListValue)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ((value != null) ? ValueOneofCase.List : ValueOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public NameAttrList Func
		{
			get
			{
				if (valueCase_ != ValueOneofCase.Func)
				{
					return null;
				}
				return (NameAttrList)value_;
			}
			set
			{
				value_ = value;
				valueCase_ = ((value != null) ? ValueOneofCase.Func : ValueOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public string Placeholder
		{
			get
			{
				if (valueCase_ != ValueOneofCase.Placeholder)
				{
					return "";
				}
				return (string)value_;
			}
			set
			{
				value_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
				valueCase_ = ValueOneofCase.Placeholder;
			}
		}

		[DebuggerNonUserCode]
		public ValueOneofCase ValueCase => valueCase_;

		[DebuggerNonUserCode]
		public AttrValue()
		{
		}

		[DebuggerNonUserCode]
		public AttrValue(AttrValue other)
			: this()
		{
			switch (other.ValueCase)
			{
			case ValueOneofCase.S:
				S = other.S;
				break;
			case ValueOneofCase.I:
				I = other.I;
				break;
			case ValueOneofCase.F:
				F = other.F;
				break;
			case ValueOneofCase.B:
				B = other.B;
				break;
			case ValueOneofCase.Type:
				Type = other.Type;
				break;
			case ValueOneofCase.Shape:
				Shape = other.Shape.Clone();
				break;
			case ValueOneofCase.Tensor:
				Tensor = other.Tensor.Clone();
				break;
			case ValueOneofCase.List:
				List = other.List.Clone();
				break;
			case ValueOneofCase.Func:
				Func = other.Func.Clone();
				break;
			case ValueOneofCase.Placeholder:
				Placeholder = other.Placeholder;
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public AttrValue Clone()
		{
			return new AttrValue(this);
		}

		[DebuggerNonUserCode]
		public void ClearValue()
		{
			valueCase_ = ValueOneofCase.None;
			value_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as AttrValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(AttrValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (S != other.S)
			{
				return false;
			}
			if (I != other.I)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(F, other.F))
			{
				return false;
			}
			if (B != other.B)
			{
				return false;
			}
			if (Type != other.Type)
			{
				return false;
			}
			if (!object.Equals(Shape, other.Shape))
			{
				return false;
			}
			if (!object.Equals(Tensor, other.Tensor))
			{
				return false;
			}
			if (!object.Equals(List, other.List))
			{
				return false;
			}
			if (!object.Equals(Func, other.Func))
			{
				return false;
			}
			if (Placeholder != other.Placeholder)
			{
				return false;
			}
			if (ValueCase != other.ValueCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (valueCase_ == ValueOneofCase.S)
			{
				num ^= ((object)S).GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.I)
			{
				num ^= I.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.F)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(F);
			}
			if (valueCase_ == ValueOneofCase.B)
			{
				num ^= B.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.Type)
			{
				num ^= Type.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.Shape)
			{
				num ^= Shape.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.Tensor)
			{
				num ^= Tensor.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.List)
			{
				num ^= List.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.Func)
			{
				num ^= Func.GetHashCode();
			}
			if (valueCase_ == ValueOneofCase.Placeholder)
			{
				num ^= Placeholder.GetHashCode();
			}
			num ^= (int)valueCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (valueCase_ == ValueOneofCase.List)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)List);
			}
			if (valueCase_ == ValueOneofCase.S)
			{
				output.WriteRawTag((byte)18);
				output.WriteBytes(S);
			}
			if (valueCase_ == ValueOneofCase.I)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(I);
			}
			if (valueCase_ == ValueOneofCase.F)
			{
				output.WriteRawTag((byte)37);
				output.WriteFloat(F);
			}
			if (valueCase_ == ValueOneofCase.B)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(B);
			}
			if (valueCase_ == ValueOneofCase.Type)
			{
				output.WriteRawTag((byte)48);
				output.WriteEnum((int)Type);
			}
			if (valueCase_ == ValueOneofCase.Shape)
			{
				output.WriteRawTag((byte)58);
				output.WriteMessage((IMessage)(object)Shape);
			}
			if (valueCase_ == ValueOneofCase.Tensor)
			{
				output.WriteRawTag((byte)66);
				output.WriteMessage((IMessage)(object)Tensor);
			}
			if (valueCase_ == ValueOneofCase.Placeholder)
			{
				output.WriteRawTag((byte)74);
				output.WriteString(Placeholder);
			}
			if (valueCase_ == ValueOneofCase.Func)
			{
				output.WriteRawTag((byte)82);
				output.WriteMessage((IMessage)(object)Func);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (valueCase_ == ValueOneofCase.S)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(S);
			}
			if (valueCase_ == ValueOneofCase.I)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(I);
			}
			if (valueCase_ == ValueOneofCase.F)
			{
				num += 5;
			}
			if (valueCase_ == ValueOneofCase.B)
			{
				num += 2;
			}
			if (valueCase_ == ValueOneofCase.Type)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Type);
			}
			if (valueCase_ == ValueOneofCase.Shape)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
			}
			if (valueCase_ == ValueOneofCase.Tensor)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Tensor);
			}
			if (valueCase_ == ValueOneofCase.List)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)List);
			}
			if (valueCase_ == ValueOneofCase.Func)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Func);
			}
			if (valueCase_ == ValueOneofCase.Placeholder)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Placeholder);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(AttrValue other)
		{
			if (other == null)
			{
				return;
			}
			switch (other.ValueCase)
			{
			case ValueOneofCase.S:
				S = other.S;
				break;
			case ValueOneofCase.I:
				I = other.I;
				break;
			case ValueOneofCase.F:
				F = other.F;
				break;
			case ValueOneofCase.B:
				B = other.B;
				break;
			case ValueOneofCase.Type:
				Type = other.Type;
				break;
			case ValueOneofCase.Shape:
				if (Shape == null)
				{
					Shape = new TensorShapeProto();
				}
				Shape.MergeFrom(other.Shape);
				break;
			case ValueOneofCase.Tensor:
				if (Tensor == null)
				{
					Tensor = new TensorProto();
				}
				Tensor.MergeFrom(other.Tensor);
				break;
			case ValueOneofCase.List:
				if (List == null)
				{
					List = new Types.ListValue();
				}
				List.MergeFrom(other.List);
				break;
			case ValueOneofCase.Func:
				if (Func == null)
				{
					Func = new NameAttrList();
				}
				Func.MergeFrom(other.Func);
				break;
			case ValueOneofCase.Placeholder:
				Placeholder = other.Placeholder;
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
				{
					Types.ListValue listValue = new Types.ListValue();
					if (valueCase_ == ValueOneofCase.List)
					{
						listValue.MergeFrom(List);
					}
					input.ReadMessage((IMessage)(object)listValue);
					List = listValue;
					break;
				}
				case 18u:
					S = input.ReadBytes();
					break;
				case 24u:
					I = input.ReadInt64();
					break;
				case 37u:
					F = input.ReadFloat();
					break;
				case 40u:
					B = input.ReadBool();
					break;
				case 48u:
					value_ = input.ReadEnum();
					valueCase_ = ValueOneofCase.Type;
					break;
				case 58u:
				{
					TensorShapeProto tensorShapeProto = new TensorShapeProto();
					if (valueCase_ == ValueOneofCase.Shape)
					{
						tensorShapeProto.MergeFrom(Shape);
					}
					input.ReadMessage((IMessage)(object)tensorShapeProto);
					Shape = tensorShapeProto;
					break;
				}
				case 66u:
				{
					TensorProto tensorProto = new TensorProto();
					if (valueCase_ == ValueOneofCase.Tensor)
					{
						tensorProto.MergeFrom(Tensor);
					}
					input.ReadMessage((IMessage)(object)tensorProto);
					Tensor = tensorProto;
					break;
				}
				case 74u:
					Placeholder = input.ReadString();
					break;
				case 82u:
				{
					NameAttrList nameAttrList = new NameAttrList();
					if (valueCase_ == ValueOneofCase.Func)
					{
						nameAttrList.MergeFrom(Func);
					}
					input.ReadMessage((IMessage)(object)nameAttrList);
					Func = nameAttrList;
					break;
				}
				}
			}
		}
	}
	public sealed class NameAttrList : IMessage<NameAttrList>, IMessage, IEquatable<NameAttrList>, IDeepCloneable<NameAttrList>
	{
		private static readonly MessageParser<NameAttrList> _parser = new MessageParser<NameAttrList>((Func<NameAttrList>)(() => new NameAttrList()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int AttrFieldNumber = 2;

		private static readonly Codec<string, AttrValue> _map_attr_codec = new Codec<string, AttrValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<AttrValue>(18u, AttrValue.Parser), 18u);

		private readonly MapField<string, AttrValue> attr_ = new MapField<string, AttrValue>();

		[DebuggerNonUserCode]
		public static MessageParser<NameAttrList> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => AttrValueReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, AttrValue> Attr => attr_;

		[DebuggerNonUserCode]
		public NameAttrList()
		{
		}

		[DebuggerNonUserCode]
		public NameAttrList(NameAttrList other)
			: this()
		{
			name_ = other.name_;
			attr_ = other.attr_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public NameAttrList Clone()
		{
			return new NameAttrList(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as NameAttrList);
		}

		[DebuggerNonUserCode]
		public bool Equals(NameAttrList other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!Attr.Equals(other.Attr))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= ((object)Attr).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			attr_.WriteTo(output, _map_attr_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += attr_.CalculateSize(_map_attr_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(NameAttrList other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				attr_.Add((IDictionary<string, AttrValue>)other.attr_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					attr_.AddEntriesFrom(input, _map_attr_codec);
					break;
				}
			}
		}
	}
	public static class ClusterReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static ClusterReflection()
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiZ0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vY2x1c3Rlci5wcm90bxILdGVu" + "c29yYm9hcmQicwoGSm9iRGVmEgwKBG5hbWUYASABKAkSLQoFdGFza3MYAiAD" + "KAsyHi50ZW5zb3Jib2FyZC5Kb2JEZWYuVGFza3NFbnRyeRosCgpUYXNrc0Vu" + "dHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoCToCOAEiLgoKQ2x1c3Rl" + "ckRlZhIgCgNqb2IYASADKAsyEy50ZW5zb3Jib2FyZC5Kb2JEZWZChwEKGm9y" + "Zy50ZW5zb3JmbG93LmRpc3RydW50aW1lQg1DbHVzdGVyUHJvdG9zUAFaVWdp" + "dGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28v" + "Y29yZS9wcm90b2J1Zi9mb3JfY29yZV9wcm90b3NfZ29fcHJvdG/4AQFiBnBy" + "b3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(JobDef), (MessageParser)(object)JobDef.Parser, new string[2] { "Name", "Tasks" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(ClusterDef), (MessageParser)(object)ClusterDef.Parser, new string[1] { "Job" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class JobDef : IMessage<JobDef>, IMessage, IEquatable<JobDef>, IDeepCloneable<JobDef>
	{
		private static readonly MessageParser<JobDef> _parser = new MessageParser<JobDef>((Func<JobDef>)(() => new JobDef()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int TasksFieldNumber = 2;

		private static readonly Codec<int, string> _map_tasks_codec = new Codec<int, string>(FieldCodec.ForInt32(8u, 0), FieldCodec.ForString(18u, ""), 18u);

		private readonly MapField<int, string> tasks_ = new MapField<int, string>();

		[DebuggerNonUserCode]
		public static MessageParser<JobDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ClusterReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public MapField<int, string> Tasks => tasks_;

		[DebuggerNonUserCode]
		public JobDef()
		{
		}

		[DebuggerNonUserCode]
		public JobDef(JobDef other)
			: this()
		{
			name_ = other.name_;
			tasks_ = other.tasks_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public JobDef Clone()
		{
			return new JobDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as JobDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(JobDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!Tasks.Equals(other.Tasks))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= ((object)Tasks).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			tasks_.WriteTo(output, _map_tasks_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += tasks_.CalculateSize(_map_tasks_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(JobDef other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				tasks_.Add((IDictionary<int, string>)other.tasks_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					tasks_.AddEntriesFrom(input, _map_tasks_codec);
					break;
				}
			}
		}
	}
	public sealed class ClusterDef : IMessage<ClusterDef>, IMessage, IEquatable<ClusterDef>, IDeepCloneable<ClusterDef>
	{
		private static readonly MessageParser<ClusterDef> _parser = new MessageParser<ClusterDef>((Func<ClusterDef>)(() => new ClusterDef()));

		private UnknownFieldSet _unknownFields;

		public const int JobFieldNumber = 1;

		private static readonly FieldCodec<JobDef> _repeated_job_codec = FieldCodec.ForMessage<JobDef>(10u, JobDef.Parser);

		private readonly RepeatedField<JobDef> job_ = new RepeatedField<JobDef>();

		[DebuggerNonUserCode]
		public static MessageParser<ClusterDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ClusterReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<JobDef> Job => job_;

		[DebuggerNonUserCode]
		public ClusterDef()
		{
		}

		[DebuggerNonUserCode]
		public ClusterDef(ClusterDef other)
			: this()
		{
			job_ = other.job_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ClusterDef Clone()
		{
			return new ClusterDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ClusterDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(ClusterDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!job_.Equals(other.job_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)job_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			job_.WriteTo(output, _repeated_job_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += job_.CalculateSize(_repeated_job_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ClusterDef other)
		{
			if (other != null)
			{
				job_.Add((IEnumerable<JobDef>)other.job_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					job_.AddEntriesFrom(input, _repeated_job_codec);
				}
			}
		}
	}
	public static class ConfigReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static ConfigReflection()
		{
			//IL_05f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ff: Expected O, but got Unknown
			//IL_05ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0605: Expected O, but got Unknown
			//IL_0605: Unknown result type (might be due to invalid IL or missing references)
			//IL_060b: Expected O, but got Unknown
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0683: Expected O, but got Unknown
			//IL_06e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ed: Expected O, but got Unknown
			//IL_0718: Unknown result type (might be due to invalid IL or missing references)
			//IL_071e: Expected O, but got Unknown
			//IL_0769: Unknown result type (might be due to invalid IL or missing references)
			//IL_076f: Expected O, but got Unknown
			//IL_079a: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a0: Expected O, but got Unknown
			//IL_092a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0930: Expected O, but got Unknown
			//IL_0930: Unknown result type (might be due to invalid IL or missing references)
			//IL_0936: Expected O, but got Unknown
			//IL_09fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a01: Expected O, but got Unknown
			//IL_0a01: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a07: Expected O, but got Unknown
			//IL_0a07: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a0d: Expected O, but got Unknown
			//IL_0a80: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a86: Expected O, but got Unknown
			//IL_0a86: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8c: Expected O, but got Unknown
			//IL_0ab8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0abe: Expected O, but got Unknown
			//IL_0b1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b25: Expected O, but got Unknown
			//IL_0b25: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b2f: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vY29uZmlnLnByb3RvEgt0ZW5z" + "b3Jib2FyZBopdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL2Nvc3RfZ3JhcGgu" + "cHJvdG8aJHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9ncmFwaC5wcm90bxop" + "dGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3N0ZXBfc3RhdHMucHJvdG8aJnRl" + "bnNvcmJvYXJkL2NvbXBhdC9wcm90by9jbHVzdGVyLnByb3RvGjJ0ZW5zb3Ji" + "b2FyZC9jb21wYXQvcHJvdG8vY29vcmRpbmF0aW9uX2NvbmZpZy5wcm90bxok" + "dGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL2RlYnVnLnByb3RvGi50ZW5zb3Ji" + "b2FyZC9jb21wYXQvcHJvdG8vcmV3cml0ZXJfY29uZmlnLnByb3RvIsEGCgpH" + "UFVPcHRpb25zEicKH3Blcl9wcm9jZXNzX2dwdV9tZW1vcnlfZnJhY3Rpb24Y" + "ASABKAESFAoMYWxsb3dfZ3Jvd3RoGAQgASgIEhYKDmFsbG9jYXRvcl90eXBl" + "GAIgASgJEh8KF2RlZmVycmVkX2RlbGV0aW9uX2J5dGVzGAMgASgDEhsKE3Zp" + "c2libGVfZGV2aWNlX2xpc3QYBSABKAkSIgoacG9sbGluZ19hY3RpdmVfZGVs" + "YXlfdXNlY3MYBiABKAUSJAoccG9sbGluZ19pbmFjdGl2ZV9kZWxheV9tc2Vj" + "cxgHIAEoBRIcChRmb3JjZV9ncHVfY29tcGF0aWJsZRgIIAEoCBI6CgxleHBl" + "cmltZW50YWwYCSABKAsyJC50ZW5zb3Jib2FyZC5HUFVPcHRpb25zLkV4cGVy" + "aW1lbnRhbBr5AwoMRXhwZXJpbWVudGFsEkwKD3ZpcnR1YWxfZGV2aWNlcxgB" + "IAMoCzIzLnRlbnNvcmJvYXJkLkdQVU9wdGlvbnMuRXhwZXJpbWVudGFsLlZp" + "cnR1YWxEZXZpY2VzEhoKEnVzZV91bmlmaWVkX21lbW9yeRgCIAEoCBIjChtu" + "dW1fZGV2X3RvX2Rldl9jb3B5X3N0cmVhbXMYAyABKAUSHQoVY29sbGVjdGl2" + "ZV9yaW5nX29yZGVyGAQgASgJEh0KFXRpbWVzdGFtcGVkX2FsbG9jYXRvchgF" + "IAEoCBIjChtrZXJuZWxfdHJhY2tlcl9tYXhfaW50ZXJ2YWwYByABKAUSIAoY" + "a2VybmVsX3RyYWNrZXJfbWF4X2J5dGVzGAggASgFEiIKGmtlcm5lbF90cmFj" + "a2VyX21heF9wZW5kaW5nGAkgASgFEicKH2ludGVybmFsX2ZyYWdtZW50YXRp" + "b25fZnJhY3Rpb24YCiABKAESHQoVdXNlX2N1ZGFfbWFsbG9jX2FzeW5jGAsg" + "ASgIEiwKJGRpc2FsbG93X3JldHJ5X29uX2FsbG9jYXRpb25fZmFpbHVyZRgM" + "IAEoCBo7Cg5WaXJ0dWFsRGV2aWNlcxIXCg9tZW1vcnlfbGltaXRfbWIYASAD" + "KAISEAoIcHJpb3JpdHkYAiADKAUinwMKEE9wdGltaXplck9wdGlvbnMSKwoj" + "ZG9fY29tbW9uX3N1YmV4cHJlc3Npb25fZWxpbWluYXRpb24YASABKAgSGwoT" + "ZG9fY29uc3RhbnRfZm9sZGluZxgCIAEoCBIkChxtYXhfZm9sZGVkX2NvbnN0" + "YW50X2luX2J5dGVzGAYgASgDEhwKFGRvX2Z1bmN0aW9uX2lubGluaW5nGAQg" + "ASgIEjYKCW9wdF9sZXZlbBgDIAEoDjIjLnRlbnNvcmJvYXJkLk9wdGltaXpl" + "ck9wdGlvbnMuTGV2ZWwSRgoQZ2xvYmFsX2ppdF9sZXZlbBgFIAEoDjIsLnRl" + "bnNvcmJvYXJkLk9wdGltaXplck9wdGlvbnMuR2xvYmFsSml0TGV2ZWwSFgoO" + "Y3B1X2dsb2JhbF9qaXQYByABKAgiIAoFTGV2ZWwSBgoCTDEQABIPCgJMMBD/" + "//////////8BIkMKDkdsb2JhbEppdExldmVsEgsKB0RFRkFVTFQQABIQCgNP" + "RkYQ////////////ARIICgRPTl8xEAESCAoET05fMhACIvACCgxHcmFwaE9w" + "dGlvbnMSHgoWZW5hYmxlX3JlY3Zfc2NoZWR1bGluZxgCIAEoCBI4ChFvcHRp" + "bWl6ZXJfb3B0aW9ucxgDIAEoCzIdLnRlbnNvcmJvYXJkLk9wdGltaXplck9w" + "dGlvbnMSGAoQYnVpbGRfY29zdF9tb2RlbBgEIAEoAxIeChZidWlsZF9jb3N0" + "X21vZGVsX2FmdGVyGAkgASgDEhQKDGluZmVyX3NoYXBlcxgFIAEoCBIaChJw" + "bGFjZV9wcnVuZWRfZ3JhcGgYBiABKAgSIAoYZW5hYmxlX2JmbG9hdDE2X3Nl" + "bmRyZWN2GAcgASgIEhUKDXRpbWVsaW5lX3N0ZXAYCCABKAUSNAoPcmV3cml0" + "ZV9vcHRpb25zGAogASgLMhsudGVuc29yYm9hcmQuUmV3cml0ZXJDb25maWdK" + "BAgBEAJSJXNraXBfY29tbW9uX3N1YmV4cHJlc3Npb25fZWxpbWluYXRpb24i" + "QQoVVGhyZWFkUG9vbE9wdGlvblByb3RvEhMKC251bV90aHJlYWRzGAEgASgF" + "EhMKC2dsb2JhbF9uYW1lGAIgASgJItUBCgpSUENPcHRpb25zEiQKHHVzZV9y" + "cGNfZm9yX2lucHJvY2Vzc19tYXN0ZXIYASABKAgSHQoVY29tcHJlc3Npb25f" + "YWxnb3JpdGhtGAIgASgJEhkKEWNvbXByZXNzaW9uX2xldmVsGAMgASgFEhoK" + "EmNhY2hlX3JwY19yZXNwb25zZRgEIAEoCBIqCiJkaXNhYmxlX3Nlc3Npb25f" + "Y29ubmVjdGlvbl9zaGFyaW5nGAUgASgIEh8KF251bV9jaGFubmVsc19wZXJf" + "dGFyZ2V0GAYgASgFIjAKD1Nlc3Npb25NZXRhZGF0YRIMCgRuYW1lGAEgASgJ" + "Eg8KB3ZlcnNpb24YAiABKAMiuA4KC0NvbmZpZ1Byb3RvEj8KDGRldmljZV9j" + "b3VudBgBIAMoCzIpLnRlbnNvcmJvYXJkLkNvbmZpZ1Byb3RvLkRldmljZUNv" + "dW50RW50cnkSJAocaW50cmFfb3BfcGFyYWxsZWxpc21fdGhyZWFkcxgCIAEo" + "BRIkChxpbnRlcl9vcF9wYXJhbGxlbGlzbV90aHJlYWRzGAUgASgFEh8KF3Vz" + "ZV9wZXJfc2Vzc2lvbl90aHJlYWRzGAkgASgIEkgKHHNlc3Npb25faW50ZXJf" + "b3BfdGhyZWFkX3Bvb2wYDCADKAsyIi50ZW5zb3Jib2FyZC5UaHJlYWRQb29s" + "T3B0aW9uUHJvdG8SGAoQcGxhY2VtZW50X3BlcmlvZBgDIAEoBRIWCg5kZXZp" + "Y2VfZmlsdGVycxgEIAMoCRIsCgtncHVfb3B0aW9ucxgGIAEoCzIXLnRlbnNv" + "cmJvYXJkLkdQVU9wdGlvbnMSHAoUYWxsb3dfc29mdF9wbGFjZW1lbnQYByAB" + "KAgSHAoUbG9nX2RldmljZV9wbGFjZW1lbnQYCCABKAgSMAoNZ3JhcGhfb3B0" + "aW9ucxgKIAEoCzIZLnRlbnNvcmJvYXJkLkdyYXBoT3B0aW9ucxIfChdvcGVy" + "YXRpb25fdGltZW91dF9pbl9tcxgLIAEoAxIsCgtycGNfb3B0aW9ucxgNIAEo" + "CzIXLnRlbnNvcmJvYXJkLlJQQ09wdGlvbnMSLAoLY2x1c3Rlcl9kZWYYDiAB" + "KAsyFy50ZW5zb3Jib2FyZC5DbHVzdGVyRGVmEh0KFWlzb2xhdGVfc2Vzc2lv" + "bl9zdGF0ZRgPIAEoCBIoCiBzaGFyZV9jbHVzdGVyX2RldmljZXNfaW5fc2Vz" + "c2lvbhgRIAEoCBI7CgxleHBlcmltZW50YWwYECABKAsyJS50ZW5zb3Jib2Fy" + "ZC5Db25maWdQcm90by5FeHBlcmltZW50YWwaMgoQRGV2aWNlQ291bnRFbnRy" + "eRILCgNrZXkYASABKAkSDQoFdmFsdWUYAiABKAU6AjgBGqsICgxFeHBlcmlt" + "ZW50YWwSHwoXY29sbGVjdGl2ZV9ncm91cF9sZWFkZXIYASABKAkSFQoNZXhl" + "Y3V0b3JfdHlwZRgDIAEoCRIaChJyZWN2X2J1Zl9tYXhfY2h1bmsYBCABKAUS" + "GQoRdXNlX251bWFfYWZmaW5pdHkYBSABKAgSNQotY29sbGVjdGl2ZV9kZXRl" + "cm1pbmlzdGljX3NlcXVlbnRpYWxfZXhlY3V0aW9uGAYgASgIEhcKD2NvbGxl" + "Y3RpdmVfbmNjbBgHIAEoCBI2Ci5zaGFyZV9zZXNzaW9uX3N0YXRlX2luX2Ns" + "dXN0ZXJzcGVjX3Byb3BhZ2F0aW9uGAggASgIEh8KF2Rpc2FibGVfdGhyZWFk" + "X3NwaW5uaW5nGAkgASgIEigKIHNoYXJlX2NsdXN0ZXJfZGV2aWNlc19pbl9z" + "ZXNzaW9uGAogASgIEjYKEHNlc3Npb25fbWV0YWRhdGEYCyABKAsyHC50ZW5z" + "b3Jib2FyZC5TZXNzaW9uTWV0YWRhdGESIQoZb3B0aW1pemVfZm9yX3N0YXRp" + "Y19ncmFwaBgMIAEoCBIaChJlbmFibGVfbWxpcl9icmlkZ2UYDSABKAgSVAoT" + "bWxpcl9icmlkZ2Vfcm9sbG91dBgRIAEoDjI3LnRlbnNvcmJvYXJkLkNvbmZp" + "Z1Byb3RvLkV4cGVyaW1lbnRhbC5NbGlyQnJpZGdlUm9sbG91dBImCh5lbmFi" + "bGVfbWxpcl9ncmFwaF9vcHRpbWl6YXRpb24YECABKAgSJwofZGlzYWJsZV9v" + "dXRwdXRfcGFydGl0aW9uX2dyYXBocxgOIAEoCBIjCht4bGFfZnVzaW9uX2F1" + "dG90dW5lcl90aHJlc2gYDyABKAMSEAoIdXNlX3RmcnQYEiABKAgSJwofZGlz" + "YWJsZV9mdW5jdGlvbmFsX29wc19sb3dlcmluZxgVIAEoCBInCh94bGFfcHJl" + "ZmVyX3NpbmdsZV9ncmFwaF9jbHVzdGVyGBYgASgIEkMKE2Nvb3JkaW5hdGlv" + "bl9jb25maWcYFyABKAsyJi50ZW5zb3Jib2FyZC5Db29yZGluYXRpb25TZXJ2" + "aWNlQ29uZmlnItoBChFNbGlyQnJpZGdlUm9sbG91dBIjCh9NTElSX0JSSURH" + "RV9ST0xMT1VUX1VOU1BFQ0lGSUVEEAASHwobTUxJUl9CUklER0VfUk9MTE9V" + "VF9FTkFCTEVEEAESIAocTUxJUl9CUklER0VfUk9MTE9VVF9ESVNBQkxFRBAC" + "EikKJU1MSVJfQlJJREdFX1JPTExPVVRfU0FGRV9NT0RFX0VOQUJMRUQQAxIy" + "Ci5NTElSX0JSSURHRV9ST0xMT1VUX1NBRkVfTU9ERV9GQUxMQkFDS19FTkFC" + "TEVEEARKBAgCEANKBAgTEBRKBAgUEBUi5QQKClJ1bk9wdGlvbnMSNwoLdHJh" + "Y2VfbGV2ZWwYASABKA4yIi50ZW5zb3Jib2FyZC5SdW5PcHRpb25zLlRyYWNl" + "TGV2ZWwSFQoNdGltZW91dF9pbl9tcxgCIAEoAxIcChRpbnRlcl9vcF90aHJl" + "YWRfcG9vbBgDIAEoBRIfChdvdXRwdXRfcGFydGl0aW9uX2dyYXBocxgFIAEo" + "CBIwCg1kZWJ1Z19vcHRpb25zGAYgASgLMhkudGVuc29yYm9hcmQuRGVidWdP" + "cHRpb25zEioKInJlcG9ydF90ZW5zb3JfYWxsb2NhdGlvbnNfdXBvbl9vb20Y" + "ByABKAgSOgoMZXhwZXJpbWVudGFsGAggASgLMiQudGVuc29yYm9hcmQuUnVu" + "T3B0aW9ucy5FeHBlcmltZW50YWwa0wEKDEV4cGVyaW1lbnRhbBIcChRjb2xs" + "ZWN0aXZlX2dyYXBoX2tleRgBIAEoAxIcChR1c2VfcnVuX2hhbmRsZXJfcG9v" + "bBgCIAEoCBJcChhydW5faGFuZGxlcl9wb29sX29wdGlvbnMYAyABKAsyOi50" + "ZW5zb3Jib2FyZC5SdW5PcHRpb25zLkV4cGVyaW1lbnRhbC5SdW5IYW5kbGVy" + "UG9vbE9wdGlvbnMaKQoVUnVuSGFuZGxlclBvb2xPcHRpb25zEhAKCHByaW9y" + "aXR5GAEgASgDIlIKClRyYWNlTGV2ZWwSDAoITk9fVFJBQ0UQABISCg5TT0ZU" + "V0FSRV9UUkFDRRABEhIKDkhBUkRXQVJFX1RSQUNFEAISDgoKRlVMTF9UUkFD" + "RRADSgQIBBAFIo4DCgtSdW5NZXRhZGF0YRIqCgpzdGVwX3N0YXRzGAEgASgL" + "MhYudGVuc29yYm9hcmQuU3RlcFN0YXRzEi0KCmNvc3RfZ3JhcGgYAiABKAsy" + "GS50ZW5zb3Jib2FyZC5Db3N0R3JhcGhEZWYSLwoQcGFydGl0aW9uX2dyYXBo" + "cxgDIAMoCzIVLnRlbnNvcmJvYXJkLkdyYXBoRGVmEkAKD2Z1bmN0aW9uX2dy" + "YXBocxgEIAMoCzInLnRlbnNvcmJvYXJkLlJ1bk1ldGFkYXRhLkZ1bmN0aW9u" + "R3JhcGhzGrABCg5GdW5jdGlvbkdyYXBocxIvChBwYXJ0aXRpb25fZ3JhcGhz" + "GAEgAygLMhUudGVuc29yYm9hcmQuR3JhcGhEZWYSNQoWcHJlX29wdGltaXph" + "dGlvbl9ncmFwaBgCIAEoCzIVLnRlbnNvcmJvYXJkLkdyYXBoRGVmEjYKF3Bv" + "c3Rfb3B0aW1pemF0aW9uX2dyYXBoGAMgASgLMhUudGVuc29yYm9hcmQuR3Jh" + "cGhEZWYiOgoQVGVuc29yQ29ubmVjdGlvbhITCgtmcm9tX3RlbnNvchgBIAEo" + "CRIRCgl0b190ZW5zb3IYAiABKAkitAMKD0NhbGxhYmxlT3B0aW9ucxIMCgRm" + "ZWVkGAEgAygJEg0KBWZldGNoGAIgAygJEg4KBnRhcmdldBgDIAMoCRIsCgty" + "dW5fb3B0aW9ucxgEIAEoCzIXLnRlbnNvcmJvYXJkLlJ1bk9wdGlvbnMSOAoR" + "dGVuc29yX2Nvbm5lY3Rpb24YBSADKAsyHS50ZW5zb3Jib2FyZC5UZW5zb3JD" + "b25uZWN0aW9uEkMKDGZlZWRfZGV2aWNlcxgGIAMoCzItLnRlbnNvcmJvYXJk" + "LkNhbGxhYmxlT3B0aW9ucy5GZWVkRGV2aWNlc0VudHJ5EkUKDWZldGNoX2Rl" + "dmljZXMYByADKAsyLi50ZW5zb3Jib2FyZC5DYWxsYWJsZU9wdGlvbnMuRmV0" + "Y2hEZXZpY2VzRW50cnkSFwoPZmV0Y2hfc2tpcF9zeW5jGAggASgIGjIKEEZl" + "ZWREZXZpY2VzRW50cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4" + "ARozChFGZXRjaERldmljZXNFbnRyeRILCgNrZXkYASABKAkSDQoFdmFsdWUY" + "AiABKAk6AjgBQoQBChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDENvbmZp" + "Z1Byb3Rvc1ABWlVnaXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90" + "ZW5zb3JmbG93L2dvL2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJvdG9zX2dv" + "X3Byb3Rv+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[7]
			{
				CostGraphReflection.Descriptor,
				GraphReflection.Descriptor,
				StepStatsReflection.Descriptor,
				ClusterReflection.Descriptor,
				CoordinationConfigReflection.Descriptor,
				DebugReflection.Descriptor,
				RewriterConfigReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[11]
			{
				new GeneratedClrTypeInfo(typeof(GPUOptions), (MessageParser)(object)GPUOptions.Parser, new string[9] { "PerProcessGpuMemoryFraction", "AllowGrowth", "AllocatorType", "DeferredDeletionBytes", "VisibleDeviceList", "PollingActiveDelayUsecs", "PollingInactiveDelayMsecs", "ForceGpuCompatible", "Experimental" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(GPUOptions.Types.Experimental), (MessageParser)(object)GPUOptions.Types.Experimental.Parser, new string[11]
					{
						"VirtualDevices", "UseUnifiedMemory", "NumDevToDevCopyStreams", "CollectiveRingOrder", "TimestampedAllocator", "KernelTrackerMaxInterval", "KernelTrackerMaxBytes", "KernelTrackerMaxPending", "InternalFragmentationFraction", "UseCudaMallocAsync",
						"DisallowRetryOnAllocationFailure"
					}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
					{
						new GeneratedClrTypeInfo(typeof(GPUOptions.Types.Experimental.Types.VirtualDevices), (MessageParser)(object)GPUOptions.Types.Experimental.Types.VirtualDevices.Parser, new string[2] { "MemoryLimitMb", "Priority" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
					})
				}),
				new GeneratedClrTypeInfo(typeof(OptimizerOptions), (MessageParser)(object)OptimizerOptions.Parser, new string[7] { "DoCommonSubexpressionElimination", "DoConstantFolding", "MaxFoldedConstantInBytes", "DoFunctionInlining", "OptLevel", "GlobalJitLevel", "CpuGlobalJit" }, (string[])null, new Type[2]
				{
					typeof(OptimizerOptions.Types.Level),
					typeof(OptimizerOptions.Types.GlobalJitLevel)
				}, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(GraphOptions), (MessageParser)(object)GraphOptions.Parser, new string[9] { "EnableRecvScheduling", "OptimizerOptions", "BuildCostModel", "BuildCostModelAfter", "InferShapes", "PlacePrunedGraph", "EnableBfloat16Sendrecv", "TimelineStep", "RewriteOptions" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ThreadPoolOptionProto), (MessageParser)(object)ThreadPoolOptionProto.Parser, new string[2] { "NumThreads", "GlobalName" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(RPCOptions), (MessageParser)(object)RPCOptions.Parser, new string[6] { "UseRpcForInprocessMaster", "CompressionAlgorithm", "CompressionLevel", "CacheRpcResponse", "DisableSessionConnectionSharing", "NumChannelsPerTarget" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SessionMetadata), (MessageParser)(object)SessionMetadata.Parser, new string[2] { "Name", "Version" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ConfigProto), (MessageParser)(object)ConfigProto.Parser, new string[17]
				{
					"DeviceCount", "IntraOpParallelismThreads", "InterOpParallelismThreads", "UsePerSessionThreads", "SessionInterOpThreadPool", "PlacementPeriod", "DeviceFilters", "GpuOptions", "AllowSoftPlacement", "LogDevicePlacement",
					"GraphOptions", "OperationTimeoutInMs", "RpcOptions", "ClusterDef", "IsolateSessionState", "ShareClusterDevicesInSession", "Experimental"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
				{
					default(GeneratedClrTypeInfo),
					new GeneratedClrTypeInfo(typeof(ConfigProto.Types.Experimental), (MessageParser)(object)ConfigProto.Types.Experimental.Parser, new string[20]
					{
						"CollectiveGroupLeader", "ExecutorType", "RecvBufMaxChunk", "UseNumaAffinity", "CollectiveDeterministicSequentialExecution", "CollectiveNccl", "ShareSessionStateInClusterspecPropagation", "DisableThreadSpinning", "ShareClusterDevicesInSession", "SessionMetadata",
						"OptimizeForStaticGraph", "EnableMlirBridge", "MlirBridgeRollout", "EnableMlirGraphOptimization", "DisableOutputPartitionGraphs", "XlaFusionAutotunerThresh", "UseTfrt", "DisableFunctionalOpsLowering", "XlaPreferSingleGraphCluster", "CoordinationConfig"
					}, (string[])null, new Type[1] { typeof(ConfigProto.Types.Experimental.Types.MlirBridgeRollout) }, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(RunOptions), (MessageParser)(object)RunOptions.Parser, new string[7] { "TraceLevel", "TimeoutInMs", "InterOpThreadPool", "OutputPartitionGraphs", "DebugOptions", "ReportTensorAllocationsUponOom", "Experimental" }, (string[])null, new Type[1] { typeof(RunOptions.Types.TraceLevel) }, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(RunOptions.Types.Experimental), (MessageParser)(object)RunOptions.Types.Experimental.Parser, new string[3] { "CollectiveGraphKey", "UseRunHandlerPool", "RunHandlerPoolOptions" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
					{
						new GeneratedClrTypeInfo(typeof(RunOptions.Types.Experimental.Types.RunHandlerPoolOptions), (MessageParser)(object)RunOptions.Types.Experimental.Types.RunHandlerPoolOptions.Parser, new string[1] { "Priority" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
					})
				}),
				new GeneratedClrTypeInfo(typeof(RunMetadata), (MessageParser)(object)RunMetadata.Parser, new string[4] { "StepStats", "CostGraph", "PartitionGraphs", "FunctionGraphs" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(RunMetadata.Types.FunctionGraphs), (MessageParser)(object)RunMetadata.Types.FunctionGraphs.Parser, new string[3] { "PartitionGraphs", "PreOptimizationGraph", "PostOptimizationGraph" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(TensorConnection), (MessageParser)(object)TensorConnection.Parser, new string[2] { "FromTensor", "ToTensor" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(CallableOptions), (MessageParser)(object)CallableOptions.Parser, new string[8] { "Feed", "Fetch", "Target", "RunOptions", "TensorConnection", "FeedDevices", "FetchDevices", "FetchSkipSync" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2])
			}));
		}
	}
	public sealed class GPUOptions : IMessage<GPUOptions>, IMessage, IEquatable<GPUOptions>, IDeepCloneable<GPUOptions>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class Experimental : IMessage<Experimental>, IMessage, IEquatable<Experimental>, IDeepCloneable<Experimental>
			{
				[DebuggerNonUserCode]
				public static class Types
				{
					public sealed class VirtualDevices : IMessage<VirtualDevices>, IMessage, IEquatable<VirtualDevices>, IDeepCloneable<VirtualDevices>
					{
						private static readonly MessageParser<VirtualDevices> _parser = new MessageParser<VirtualDevices>((Func<VirtualDevices>)(() => new VirtualDevices()));

						private UnknownFieldSet _unknownFields;

						public const int MemoryLimitMbFieldNumber = 1;

						private static readonly FieldCodec<float> _repeated_memoryLimitMb_codec = FieldCodec.ForFloat(10u);

						private readonly RepeatedField<float> memoryLimitMb_ = new RepeatedField<float>();

						public const int PriorityFieldNumber = 2;

						private static readonly FieldCodec<int> _repeated_priority_codec = FieldCodec.ForInt32(18u);

						private readonly RepeatedField<int> priority_ = new RepeatedField<int>();

						[DebuggerNonUserCode]
						public static MessageParser<VirtualDevices> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => Experimental.Descriptor.NestedTypes[0];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public RepeatedField<float> MemoryLimitMb => memoryLimitMb_;

						[DebuggerNonUserCode]
						public RepeatedField<int> Priority => priority_;

						[DebuggerNonUserCode]
						public VirtualDevices()
						{
						}

						[DebuggerNonUserCode]
						public VirtualDevices(VirtualDevices other)
							: this()
						{
							memoryLimitMb_ = other.memoryLimitMb_.Clone();
							priority_ = other.priority_.Clone();
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public VirtualDevices Clone()
						{
							return new VirtualDevices(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as VirtualDevices);
						}

						[DebuggerNonUserCode]
						public bool Equals(VirtualDevices other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (!memoryLimitMb_.Equals(other.memoryLimitMb_))
							{
								return false;
							}
							if (!priority_.Equals(other.priority_))
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							num ^= ((object)memoryLimitMb_).GetHashCode();
							num ^= ((object)priority_).GetHashCode();
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							memoryLimitMb_.WriteTo(output, _repeated_memoryLimitMb_codec);
							priority_.WriteTo(output, _repeated_priority_codec);
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							num += memoryLimitMb_.CalculateSize(_repeated_memoryLimitMb_codec);
							num += priority_.CalculateSize(_repeated_priority_codec);
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(VirtualDevices other)
						{
							if (other != null)
							{
								memoryLimitMb_.Add((IEnumerable<float>)other.memoryLimitMb_);
								priority_.Add((IEnumerable<int>)other.priority_);
								_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
							}
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								switch (num)
								{
								default:
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
									break;
								case 10u:
								case 13u:
									memoryLimitMb_.AddEntriesFrom(input, _repeated_memoryLimitMb_codec);
									break;
								case 16u:
								case 18u:
									priority_.AddEntriesFrom(input, _repeated_priority_codec);
									break;
								}
							}
						}
					}
				}

				private static readonly MessageParser<Experimental> _parser = new MessageParser<Experimental>((Func<Experimental>)(() => new Experimental()));

				private UnknownFieldSet _unknownFields;

				public const int VirtualDevicesFieldNumber = 1;

				private static readonly FieldCodec<Types.VirtualDevices> _repeated_virtualDevices_codec = FieldCodec.ForMessage<Types.VirtualDevices>(10u, Types.VirtualDevices.Parser);

				private readonly RepeatedField<Types.VirtualDevices> virtualDevices_ = new RepeatedField<Types.VirtualDevices>();

				public const int UseUnifiedMemoryFieldNumber = 2;

				private bool useUnifiedMemory_;

				public const int NumDevToDevCopyStreamsFieldNumber = 3;

				private int numDevToDevCopyStreams_;

				public const int CollectiveRingOrderFieldNumber = 4;

				private string collectiveRingOrder_ = "";

				public const int TimestampedAllocatorFieldNumber = 5;

				private bool timestampedAllocator_;

				public const int KernelTrackerMaxIntervalFieldNumber = 7;

				private int kernelTrackerMaxInterval_;

				public const int KernelTrackerMaxBytesFieldNumber = 8;

				private int kernelTrackerMaxBytes_;

				public const int KernelTrackerMaxPendingFieldNumber = 9;

				private int kernelTrackerMaxPending_;

				public const int InternalFragmentationFractionFieldNumber = 10;

				private double internalFragmentationFraction_;

				public const int UseCudaMallocAsyncFieldNumber = 11;

				private bool useCudaMallocAsync_;

				public const int DisallowRetryOnAllocationFailureFieldNumber = 12;

				private bool disallowRetryOnAllocationFailure_;

				[DebuggerNonUserCode]
				public static MessageParser<Experimental> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => GPUOptions.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<Types.VirtualDevices> VirtualDevices => virtualDevices_;

				[DebuggerNonUserCode]
				public bool UseUnifiedMemory
				{
					get
					{
						return useUnifiedMemory_;
					}
					set
					{
						useUnifiedMemory_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int NumDevToDevCopyStreams
				{
					get
					{
						return numDevToDevCopyStreams_;
					}
					set
					{
						numDevToDevCopyStreams_ = value;
					}
				}

				[DebuggerNonUserCode]
				public string CollectiveRingOrder
				{
					get
					{
						return collectiveRingOrder_;
					}
					set
					{
						collectiveRingOrder_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public bool TimestampedAllocator
				{
					get
					{
						return timestampedAllocator_;
					}
					set
					{
						timestampedAllocator_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int KernelTrackerMaxInterval
				{
					get
					{
						return kernelTrackerMaxInterval_;
					}
					set
					{
						kernelTrackerMaxInterval_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int KernelTrackerMaxBytes
				{
					get
					{
						return kernelTrackerMaxBytes_;
					}
					set
					{
						kernelTrackerMaxBytes_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int KernelTrackerMaxPending
				{
					get
					{
						return kernelTrackerMaxPending_;
					}
					set
					{
						kernelTrackerMaxPending_ = value;
					}
				}

				[DebuggerNonUserCode]
				public double InternalFragmentationFraction
				{
					get
					{
						return internalFragmentationFraction_;
					}
					set
					{
						internalFragmentationFraction_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool UseCudaMallocAsync
				{
					get
					{
						return useCudaMallocAsync_;
					}
					set
					{
						useCudaMallocAsync_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool DisallowRetryOnAllocationFailure
				{
					get
					{
						return disallowRetryOnAllocationFailure_;
					}
					set
					{
						disallowRetryOnAllocationFailure_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Experimental()
				{
				}

				[DebuggerNonUserCode]
				public Experimental(Experimental other)
					: this()
				{
					virtualDevices_ = other.virtualDevices_.Clone();
					useUnifiedMemory_ = other.useUnifiedMemory_;
					numDevToDevCopyStreams_ = other.numDevToDevCopyStreams_;
					collectiveRingOrder_ = other.collectiveRingOrder_;
					timestampedAllocator_ = other.timestampedAllocator_;
					kernelTrackerMaxInterval_ = other.kernelTrackerMaxInterval_;
					kernelTrackerMaxBytes_ = other.kernelTrackerMaxBytes_;
					kernelTrackerMaxPending_ = other.kernelTrackerMaxPending_;
					internalFragmentationFraction_ = other.internalFragmentationFraction_;
					useCudaMallocAsync_ = other.useCudaMallocAsync_;
					disallowRetryOnAllocationFailure_ = other.disallowRetryOnAllocationFailure_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Experimental Clone()
				{
					return new Experimental(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Experimental);
				}

				[DebuggerNonUserCode]
				public bool Equals(Experimental other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!virtualDevices_.Equals(other.virtualDevices_))
					{
						return false;
					}
					if (UseUnifiedMemory != other.UseUnifiedMemory)
					{
						return false;
					}
					if (NumDevToDevCopyStreams != other.NumDevToDevCopyStreams)
					{
						return false;
					}
					if (CollectiveRingOrder != other.CollectiveRingOrder)
					{
						return false;
					}
					if (TimestampedAllocator != other.TimestampedAllocator)
					{
						return false;
					}
					if (KernelTrackerMaxInterval != other.KernelTrackerMaxInterval)
					{
						return false;
					}
					if (KernelTrackerMaxBytes != other.KernelTrackerMaxBytes)
					{
						return false;
					}
					if (KernelTrackerMaxPending != other.KernelTrackerMaxPending)
					{
						return false;
					}
					if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(InternalFragmentationFraction, other.InternalFragmentationFraction))
					{
						return false;
					}
					if (UseCudaMallocAsync != other.UseCudaMallocAsync)
					{
						return false;
					}
					if (DisallowRetryOnAllocationFailure != other.DisallowRetryOnAllocationFailure)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)virtualDevices_).GetHashCode();
					if (UseUnifiedMemory)
					{
						num ^= UseUnifiedMemory.GetHashCode();
					}
					if (NumDevToDevCopyStreams != 0)
					{
						num ^= NumDevToDevCopyStreams.GetHashCode();
					}
					if (CollectiveRingOrder.Length != 0)
					{
						num ^= CollectiveRingOrder.GetHashCode();
					}
					if (TimestampedAllocator)
					{
						num ^= TimestampedAllocator.GetHashCode();
					}
					if (KernelTrackerMaxInterval != 0)
					{
						num ^= KernelTrackerMaxInterval.GetHashCode();
					}
					if (KernelTrackerMaxBytes != 0)
					{
						num ^= KernelTrackerMaxBytes.GetHashCode();
					}
					if (KernelTrackerMaxPending != 0)
					{
						num ^= KernelTrackerMaxPending.GetHashCode();
					}
					if (InternalFragmentationFraction != 0.0)
					{
						num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(InternalFragmentationFraction);
					}
					if (UseCudaMallocAsync)
					{
						num ^= UseCudaMallocAsync.GetHashCode();
					}
					if (DisallowRetryOnAllocationFailure)
					{
						num ^= DisallowRetryOnAllocationFailure.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					virtualDevices_.WriteTo(output, _repeated_virtualDevices_codec);
					if (UseUnifiedMemory)
					{
						output.WriteRawTag((byte)16);
						output.WriteBool(UseUnifiedMemory);
					}
					if (NumDevToDevCopyStreams != 0)
					{
						output.WriteRawTag((byte)24);
						output.WriteInt32(NumDevToDevCopyStreams);
					}
					if (CollectiveRingOrder.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteString(CollectiveRingOrder);
					}
					if (TimestampedAllocator)
					{
						output.WriteRawTag((byte)40);
						output.WriteBool(TimestampedAllocator);
					}
					if (KernelTrackerMaxInterval != 0)
					{
						output.WriteRawTag((byte)56);
						output.WriteInt32(KernelTrackerMaxInterval);
					}
					if (KernelTrackerMaxBytes != 0)
					{
						output.WriteRawTag((byte)64);
						output.WriteInt32(KernelTrackerMaxBytes);
					}
					if (KernelTrackerMaxPending != 0)
					{
						output.WriteRawTag((byte)72);
						output.WriteInt32(KernelTrackerMaxPending);
					}
					if (InternalFragmentationFraction != 0.0)
					{
						output.WriteRawTag((byte)81);
						output.WriteDouble(InternalFragmentationFraction);
					}
					if (UseCudaMallocAsync)
					{
						output.WriteRawTag((byte)88);
						output.WriteBool(UseCudaMallocAsync);
					}
					if (DisallowRetryOnAllocationFailure)
					{
						output.WriteRawTag((byte)96);
						output.WriteBool(DisallowRetryOnAllocationFailure);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += virtualDevices_.CalculateSize(_repeated_virtualDevices_codec);
					if (UseUnifiedMemory)
					{
						num += 2;
					}
					if (NumDevToDevCopyStreams != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(NumDevToDevCopyStreams);
					}
					if (CollectiveRingOrder.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(CollectiveRingOrder);
					}
					if (TimestampedAllocator)
					{
						num += 2;
					}
					if (KernelTrackerMaxInterval != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(KernelTrackerMaxInterval);
					}
					if (KernelTrackerMaxBytes != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(KernelTrackerMaxBytes);
					}
					if (KernelTrackerMaxPending != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(KernelTrackerMaxPending);
					}
					if (InternalFragmentationFraction != 0.0)
					{
						num += 9;
					}
					if (UseCudaMallocAsync)
					{
						num += 2;
					}
					if (DisallowRetryOnAllocationFailure)
					{
						num += 2;
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Experimental other)
				{
					if (other != null)
					{
						virtualDevices_.Add((IEnumerable<Types.VirtualDevices>)other.virtualDevices_);
						if (other.UseUnifiedMemory)
						{
							UseUnifiedMemory = other.UseUnifiedMemory;
						}
						if (other.NumDevToDevCopyStreams != 0)
						{
							NumDevToDevCopyStreams = other.NumDevToDevCopyStreams;
						}
						if (other.CollectiveRingOrder.Length != 0)
						{
							CollectiveRingOrder = other.CollectiveRingOrder;
						}
						if (other.TimestampedAllocator)
						{
							TimestampedAllocator = other.TimestampedAllocator;
						}
						if (other.KernelTrackerMaxInterval != 0)
						{
							KernelTrackerMaxInterval = other.KernelTrackerMaxInterval;
						}
						if (other.KernelTrackerMaxBytes != 0)
						{
							KernelTrackerMaxBytes = other.KernelTrackerMaxBytes;
						}
						if (other.KernelTrackerMaxPending != 0)
						{
							KernelTrackerMaxPending = other.KernelTrackerMaxPending;
						}
						if (other.InternalFragmentationFraction != 0.0)
						{
							InternalFragmentationFraction = other.InternalFragmentationFraction;
						}
						if (other.UseCudaMallocAsync)
						{
							UseCudaMallocAsync = other.UseCudaMallocAsync;
						}
						if (other.DisallowRetryOnAllocationFailure)
						{
							DisallowRetryOnAllocationFailure = other.DisallowRetryOnAllocationFailure;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							virtualDevices_.AddEntriesFrom(input, _repeated_virtualDevices_codec);
							break;
						case 16u:
							UseUnifiedMemory = input.ReadBool();
							break;
						case 24u:
							NumDevToDevCopyStreams = input.ReadInt32();
							break;
						case 34u:
							CollectiveRingOrder = input.ReadString();
							break;
						case 40u:
							TimestampedAllocator = input.ReadBool();
							break;
						case 56u:
							KernelTrackerMaxInterval = input.ReadInt32();
							break;
						case 64u:
							KernelTrackerMaxBytes = input.ReadInt32();
							break;
						case 72u:
							KernelTrackerMaxPending = input.ReadInt32();
							break;
						case 81u:
							InternalFragmentationFraction = input.ReadDouble();
							break;
						case 88u:
							UseCudaMallocAsync = input.ReadBool();
							break;
						case 96u:
							DisallowRetryOnAllocationFailure = input.ReadBool();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<GPUOptions> _parser = new MessageParser<GPUOptions>((Func<GPUOptions>)(() => new GPUOptions()));

		private UnknownFieldSet _unknownFields;

		public const int PerProcessGpuMemoryFractionFieldNumber = 1;

		private double perProcessGpuMemoryFraction_;

		public const int AllowGrowthFieldNumber = 4;

		private bool allowGrowth_;

		public const int AllocatorTypeFieldNumber = 2;

		private string allocatorType_ = "";

		public const int DeferredDeletionBytesFieldNumber = 3;

		private long deferredDeletionBytes_;

		public const int VisibleDeviceListFieldNumber = 5;

		private string visibleDeviceList_ = "";

		public const int PollingActiveDelayUsecsFieldNumber = 6;

		private int pollingActiveDelayUsecs_;

		public const int PollingInactiveDelayMsecsFieldNumber = 7;

		private int pollingInactiveDelayMsecs_;

		public const int ForceGpuCompatibleFieldNumber = 8;

		private bool forceGpuCompatible_;

		public const int ExperimentalFieldNumber = 9;

		private Types.Experimental experimental_;

		[DebuggerNonUserCode]
		public static MessageParser<GPUOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public double PerProcessGpuMemoryFraction
		{
			get
			{
				return perProcessGpuMemoryFraction_;
			}
			set
			{
				perProcessGpuMemoryFraction_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool AllowGrowth
		{
			get
			{
				return allowGrowth_;
			}
			set
			{
				allowGrowth_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string AllocatorType
		{
			get
			{
				return allocatorType_;
			}
			set
			{
				allocatorType_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long DeferredDeletionBytes
		{
			get
			{
				return deferredDeletionBytes_;
			}
			set
			{
				deferredDeletionBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string VisibleDeviceList
		{
			get
			{
				return visibleDeviceList_;
			}
			set
			{
				visibleDeviceList_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public int PollingActiveDelayUsecs
		{
			get
			{
				return pollingActiveDelayUsecs_;
			}
			set
			{
				pollingActiveDelayUsecs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int PollingInactiveDelayMsecs
		{
			get
			{
				return pollingInactiveDelayMsecs_;
			}
			set
			{
				pollingInactiveDelayMsecs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool ForceGpuCompatible
		{
			get
			{
				return forceGpuCompatible_;
			}
			set
			{
				forceGpuCompatible_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Experimental Experimental
		{
			get
			{
				return experimental_;
			}
			set
			{
				experimental_ = value;
			}
		}

		[DebuggerNonUserCode]
		public GPUOptions()
		{
		}

		[DebuggerNonUserCode]
		public GPUOptions(GPUOptions other)
			: this()
		{
			perProcessGpuMemoryFraction_ = other.perProcessGpuMemoryFraction_;
			allowGrowth_ = other.allowGrowth_;
			allocatorType_ = other.allocatorType_;
			deferredDeletionBytes_ = other.deferredDeletionBytes_;
			visibleDeviceList_ = other.visibleDeviceList_;
			pollingActiveDelayUsecs_ = other.pollingActiveDelayUsecs_;
			pollingInactiveDelayMsecs_ = other.pollingInactiveDelayMsecs_;
			forceGpuCompatible_ = other.forceGpuCompatible_;
			experimental_ = ((other.experimental_ != null) ? other.experimental_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public GPUOptions Clone()
		{
			return new GPUOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as GPUOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(GPUOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(PerProcessGpuMemoryFraction, other.PerProcessGpuMemoryFraction))
			{
				return false;
			}
			if (AllowGrowth != other.AllowGrowth)
			{
				return false;
			}
			if (AllocatorType != other.AllocatorType)
			{
				return false;
			}
			if (DeferredDeletionBytes != other.DeferredDeletionBytes)
			{
				return false;
			}
			if (VisibleDeviceList != other.VisibleDeviceList)
			{
				return false;
			}
			if (PollingActiveDelayUsecs != other.PollingActiveDelayUsecs)
			{
				return false;
			}
			if (PollingInactiveDelayMsecs != other.PollingInactiveDelayMsecs)
			{
				return false;
			}
			if (ForceGpuCompatible != other.ForceGpuCompatible)
			{
				return false;
			}
			if (!object.Equals(Experimental, other.Experimental))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (PerProcessGpuMemoryFraction != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(PerProcessGpuMemoryFraction);
			}
			if (AllowGrowth)
			{
				num ^= AllowGrowth.GetHashCode();
			}
			if (AllocatorType.Length != 0)
			{
				num ^= AllocatorType.GetHashCode();
			}
			if (DeferredDeletionBytes != 0L)
			{
				num ^= DeferredDeletionBytes.GetHashCode();
			}
			if (VisibleDeviceList.Length != 0)
			{
				num ^= VisibleDeviceList.GetHashCode();
			}
			if (PollingActiveDelayUsecs != 0)
			{
				num ^= PollingActiveDelayUsecs.GetHashCode();
			}
			if (PollingInactiveDelayMsecs != 0)
			{
				num ^= PollingInactiveDelayMsecs.GetHashCode();
			}
			if (ForceGpuCompatible)
			{
				num ^= ForceGpuCompatible.GetHashCode();
			}
			if (experimental_ != null)
			{
				num ^= Experimental.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (PerProcessGpuMemoryFraction != 0.0)
			{
				output.WriteRawTag((byte)9);
				output.WriteDouble(PerProcessGpuMemoryFraction);
			}
			if (AllocatorType.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(AllocatorType);
			}
			if (DeferredDeletionBytes != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(DeferredDeletionBytes);
			}
			if (AllowGrowth)
			{
				output.WriteRawTag((byte)32);
				output.WriteBool(AllowGrowth);
			}
			if (VisibleDeviceList.Length != 0)
			{
				output.WriteRawTag((byte)42);
				output.WriteString(VisibleDeviceList);
			}
			if (PollingActiveDelayUsecs != 0)
			{
				output.WriteRawTag((byte)48);
				output.WriteInt32(PollingActiveDelayUsecs);
			}
			if (PollingInactiveDelayMsecs != 0)
			{
				output.WriteRawTag((byte)56);
				output.WriteInt32(PollingInactiveDelayMsecs);
			}
			if (ForceGpuCompatible)
			{
				output.WriteRawTag((byte)64);
				output.WriteBool(ForceGpuCompatible);
			}
			if (experimental_ != null)
			{
				output.WriteRawTag((byte)74);
				output.WriteMessage((IMessage)(object)Experimental);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (PerProcessGpuMemoryFraction != 0.0)
			{
				num += 9;
			}
			if (AllowGrowth)
			{
				num += 2;
			}
			if (AllocatorType.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(AllocatorType);
			}
			if (DeferredDeletionBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(DeferredDeletionBytes);
			}
			if (VisibleDeviceList.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(VisibleDeviceList);
			}
			if (PollingActiveDelayUsecs != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(PollingActiveDelayUsecs);
			}
			if (PollingInactiveDelayMsecs != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(PollingInactiveDelayMsecs);
			}
			if (ForceGpuCompatible)
			{
				num += 2;
			}
			if (experimental_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Experimental);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(GPUOptions other)
		{
			if (other == null)
			{
				return;
			}
			if (other.PerProcessGpuMemoryFraction != 0.0)
			{
				PerProcessGpuMemoryFraction = other.PerProcessGpuMemoryFraction;
			}
			if (other.AllowGrowth)
			{
				AllowGrowth = other.AllowGrowth;
			}
			if (other.AllocatorType.Length != 0)
			{
				AllocatorType = other.AllocatorType;
			}
			if (other.DeferredDeletionBytes != 0L)
			{
				DeferredDeletionBytes = other.DeferredDeletionBytes;
			}
			if (other.VisibleDeviceList.Length != 0)
			{
				VisibleDeviceList = other.VisibleDeviceList;
			}
			if (other.PollingActiveDelayUsecs != 0)
			{
				PollingActiveDelayUsecs = other.PollingActiveDelayUsecs;
			}
			if (other.PollingInactiveDelayMsecs != 0)
			{
				PollingInactiveDelayMsecs = other.PollingInactiveDelayMsecs;
			}
			if (other.ForceGpuCompatible)
			{
				ForceGpuCompatible = other.ForceGpuCompatible;
			}
			if (other.experimental_ != null)
			{
				if (experimental_ == null)
				{
					Experimental = new Types.Experimental();
				}
				Experimental.MergeFrom(other.Experimental);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 9u:
					PerProcessGpuMemoryFraction = input.ReadDouble();
					break;
				case 18u:
					AllocatorType = input.ReadString();
					break;
				case 24u:
					DeferredDeletionBytes = input.ReadInt64();
					break;
				case 32u:
					AllowGrowth = input.ReadBool();
					break;
				case 42u:
					VisibleDeviceList = input.ReadString();
					break;
				case 48u:
					PollingActiveDelayUsecs = input.ReadInt32();
					break;
				case 56u:
					PollingInactiveDelayMsecs = input.ReadInt32();
					break;
				case 64u:
					ForceGpuCompatible = input.ReadBool();
					break;
				case 74u:
					if (experimental_ == null)
					{
						Experimental = new Types.Experimental();
					}
					input.ReadMessage((IMessage)(object)Experimental);
					break;
				}
			}
		}
	}
	public sealed class OptimizerOptions : IMessage<OptimizerOptions>, IMessage, IEquatable<OptimizerOptions>, IDeepCloneable<OptimizerOptions>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum Level
			{
				[OriginalName("L1")]
				L1 = 0,
				[OriginalName("L0")]
				L0 = -1
			}

			public enum GlobalJitLevel
			{
				[OriginalName("DEFAULT")]
				Default = 0,
				[OriginalName("OFF")]
				Off = -1,
				[OriginalName("ON_1")]
				On1 = 1,
				[OriginalName("ON_2")]
				On2 = 2
			}
		}

		private static readonly MessageParser<OptimizerOptions> _parser = new MessageParser<OptimizerOptions>((Func<OptimizerOptions>)(() => new OptimizerOptions()));

		private UnknownFieldSet _unknownFields;

		public const int DoCommonSubexpressionEliminationFieldNumber = 1;

		private bool doCommonSubexpressionElimination_;

		public const int DoConstantFoldingFieldNumber = 2;

		private bool doConstantFolding_;

		public const int MaxFoldedConstantInBytesFieldNumber = 6;

		private long maxFoldedConstantInBytes_;

		public const int DoFunctionInliningFieldNumber = 4;

		private bool doFunctionInlining_;

		public const int OptLevelFieldNumber = 3;

		private Types.Level optLevel_;

		public const int GlobalJitLevelFieldNumber = 5;

		private Types.GlobalJitLevel globalJitLevel_;

		public const int CpuGlobalJitFieldNumber = 7;

		private bool cpuGlobalJit_;

		[DebuggerNonUserCode]
		public static MessageParser<OptimizerOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public bool DoCommonSubexpressionElimination
		{
			get
			{
				return doCommonSubexpressionElimination_;
			}
			set
			{
				doCommonSubexpressionElimination_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool DoConstantFolding
		{
			get
			{
				return doConstantFolding_;
			}
			set
			{
				doConstantFolding_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long MaxFoldedConstantInBytes
		{
			get
			{
				return maxFoldedConstantInBytes_;
			}
			set
			{
				maxFoldedConstantInBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool DoFunctionInlining
		{
			get
			{
				return doFunctionInlining_;
			}
			set
			{
				doFunctionInlining_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Level OptLevel
		{
			get
			{
				return optLevel_;
			}
			set
			{
				optLevel_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.GlobalJitLevel GlobalJitLevel
		{
			get
			{
				return globalJitLevel_;
			}
			set
			{
				globalJitLevel_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool CpuGlobalJit
		{
			get
			{
				return cpuGlobalJit_;
			}
			set
			{
				cpuGlobalJit_ = value;
			}
		}

		[DebuggerNonUserCode]
		public OptimizerOptions()
		{
		}

		[DebuggerNonUserCode]
		public OptimizerOptions(OptimizerOptions other)
			: this()
		{
			doCommonSubexpressionElimination_ = other.doCommonSubexpressionElimination_;
			doConstantFolding_ = other.doConstantFolding_;
			maxFoldedConstantInBytes_ = other.maxFoldedConstantInBytes_;
			doFunctionInlining_ = other.doFunctionInlining_;
			optLevel_ = other.optLevel_;
			globalJitLevel_ = other.globalJitLevel_;
			cpuGlobalJit_ = other.cpuGlobalJit_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public OptimizerOptions Clone()
		{
			return new OptimizerOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as OptimizerOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(OptimizerOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (DoCommonSubexpressionElimination != other.DoCommonSubexpressionElimination)
			{
				return false;
			}
			if (DoConstantFolding != other.DoConstantFolding)
			{
				return false;
			}
			if (MaxFoldedConstantInBytes != other.MaxFoldedConstantInBytes)
			{
				return false;
			}
			if (DoFunctionInlining != other.DoFunctionInlining)
			{
				return false;
			}
			if (OptLevel != other.OptLevel)
			{
				return false;
			}
			if (GlobalJitLevel != other.GlobalJitLevel)
			{
				return false;
			}
			if (CpuGlobalJit != other.CpuGlobalJit)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (DoCommonSubexpressionElimination)
			{
				num ^= DoCommonSubexpressionElimination.GetHashCode();
			}
			if (DoConstantFolding)
			{
				num ^= DoConstantFolding.GetHashCode();
			}
			if (MaxFoldedConstantInBytes != 0L)
			{
				num ^= MaxFoldedConstantInBytes.GetHashCode();
			}
			if (DoFunctionInlining)
			{
				num ^= DoFunctionInlining.GetHashCode();
			}
			if (OptLevel != Types.Level.L1)
			{
				num ^= OptLevel.GetHashCode();
			}
			if (GlobalJitLevel != Types.GlobalJitLevel.Default)
			{
				num ^= GlobalJitLevel.GetHashCode();
			}
			if (CpuGlobalJit)
			{
				num ^= CpuGlobalJit.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (DoCommonSubexpressionElimination)
			{
				output.WriteRawTag((byte)8);
				output.WriteBool(DoCommonSubexpressionElimination);
			}
			if (DoConstantFolding)
			{
				output.WriteRawTag((byte)16);
				output.WriteBool(DoConstantFolding);
			}
			if (OptLevel != Types.Level.L1)
			{
				output.WriteRawTag((byte)24);
				output.WriteEnum((int)OptLevel);
			}
			if (DoFunctionInlining)
			{
				output.WriteRawTag((byte)32);
				output.WriteBool(DoFunctionInlining);
			}
			if (GlobalJitLevel != Types.GlobalJitLevel.Default)
			{
				output.WriteRawTag((byte)40);
				output.WriteEnum((int)GlobalJitLevel);
			}
			if (MaxFoldedConstantInBytes != 0L)
			{
				output.WriteRawTag((byte)48);
				output.WriteInt64(MaxFoldedConstantInBytes);
			}
			if (CpuGlobalJit)
			{
				output.WriteRawTag((byte)56);
				output.WriteBool(CpuGlobalJit);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (DoCommonSubexpressionElimination)
			{
				num += 2;
			}
			if (DoConstantFolding)
			{
				num += 2;
			}
			if (MaxFoldedConstantInBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(MaxFoldedConstantInBytes);
			}
			if (DoFunctionInlining)
			{
				num += 2;
			}
			if (OptLevel != Types.Level.L1)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)OptLevel);
			}
			if (GlobalJitLevel != Types.GlobalJitLevel.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)GlobalJitLevel);
			}
			if (CpuGlobalJit)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(OptimizerOptions other)
		{
			if (other != null)
			{
				if (other.DoCommonSubexpressionElimination)
				{
					DoCommonSubexpressionElimination = other.DoCommonSubexpressionElimination;
				}
				if (other.DoConstantFolding)
				{
					DoConstantFolding = other.DoConstantFolding;
				}
				if (other.MaxFoldedConstantInBytes != 0L)
				{
					MaxFoldedConstantInBytes = other.MaxFoldedConstantInBytes;
				}
				if (other.DoFunctionInlining)
				{
					DoFunctionInlining = other.DoFunctionInlining;
				}
				if (other.OptLevel != Types.Level.L1)
				{
					OptLevel = other.OptLevel;
				}
				if (other.GlobalJitLevel != Types.GlobalJitLevel.Default)
				{
					GlobalJitLevel = other.GlobalJitLevel;
				}
				if (other.CpuGlobalJit)
				{
					CpuGlobalJit = other.CpuGlobalJit;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					DoCommonSubexpressionElimination = input.ReadBool();
					break;
				case 16u:
					DoConstantFolding = input.ReadBool();
					break;
				case 24u:
					OptLevel = (Types.Level)input.ReadEnum();
					break;
				case 32u:
					DoFunctionInlining = input.ReadBool();
					break;
				case 40u:
					GlobalJitLevel = (Types.GlobalJitLevel)input.ReadEnum();
					break;
				case 48u:
					MaxFoldedConstantInBytes = input.ReadInt64();
					break;
				case 56u:
					CpuGlobalJit = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class GraphOptions : IMessage<GraphOptions>, IMessage, IEquatable<GraphOptions>, IDeepCloneable<GraphOptions>
	{
		private static readonly MessageParser<GraphOptions> _parser = new MessageParser<GraphOptions>((Func<GraphOptions>)(() => new GraphOptions()));

		private UnknownFieldSet _unknownFields;

		public const int EnableRecvSchedulingFieldNumber = 2;

		private bool enableRecvScheduling_;

		public const int OptimizerOptionsFieldNumber = 3;

		private OptimizerOptions optimizerOptions_;

		public const int BuildCostModelFieldNumber = 4;

		private long buildCostModel_;

		public const int BuildCostModelAfterFieldNumber = 9;

		private long buildCostModelAfter_;

		public const int InferShapesFieldNumber = 5;

		private bool inferShapes_;

		public const int PlacePrunedGraphFieldNumber = 6;

		private bool placePrunedGraph_;

		public const int EnableBfloat16SendrecvFieldNumber = 7;

		private bool enableBfloat16Sendrecv_;

		public const int TimelineStepFieldNumber = 8;

		private int timelineStep_;

		public const int RewriteOptionsFieldNumber = 10;

		private RewriterConfig rewriteOptions_;

		[DebuggerNonUserCode]
		public static MessageParser<GraphOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public bool EnableRecvScheduling
		{
			get
			{
				return enableRecvScheduling_;
			}
			set
			{
				enableRecvScheduling_ = value;
			}
		}

		[DebuggerNonUserCode]
		public OptimizerOptions OptimizerOptions
		{
			get
			{
				return optimizerOptions_;
			}
			set
			{
				optimizerOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long BuildCostModel
		{
			get
			{
				return buildCostModel_;
			}
			set
			{
				buildCostModel_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long BuildCostModelAfter
		{
			get
			{
				return buildCostModelAfter_;
			}
			set
			{
				buildCostModelAfter_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool InferShapes
		{
			get
			{
				return inferShapes_;
			}
			set
			{
				inferShapes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool PlacePrunedGraph
		{
			get
			{
				return placePrunedGraph_;
			}
			set
			{
				placePrunedGraph_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool EnableBfloat16Sendrecv
		{
			get
			{
				return enableBfloat16Sendrecv_;
			}
			set
			{
				enableBfloat16Sendrecv_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int TimelineStep
		{
			get
			{
				return timelineStep_;
			}
			set
			{
				timelineStep_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RewriterConfig RewriteOptions
		{
			get
			{
				return rewriteOptions_;
			}
			set
			{
				rewriteOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public GraphOptions()
		{
		}

		[DebuggerNonUserCode]
		public GraphOptions(GraphOptions other)
			: this()
		{
			enableRecvScheduling_ = other.enableRecvScheduling_;
			optimizerOptions_ = ((other.optimizerOptions_ != null) ? other.optimizerOptions_.Clone() : null);
			buildCostModel_ = other.buildCostModel_;
			buildCostModelAfter_ = other.buildCostModelAfter_;
			inferShapes_ = other.inferShapes_;
			placePrunedGraph_ = other.placePrunedGraph_;
			enableBfloat16Sendrecv_ = other.enableBfloat16Sendrecv_;
			timelineStep_ = other.timelineStep_;
			rewriteOptions_ = ((other.rewriteOptions_ != null) ? other.rewriteOptions_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public GraphOptions Clone()
		{
			return new GraphOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as GraphOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(GraphOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (EnableRecvScheduling != other.EnableRecvScheduling)
			{
				return false;
			}
			if (!object.Equals(OptimizerOptions, other.OptimizerOptions))
			{
				return false;
			}
			if (BuildCostModel != other.BuildCostModel)
			{
				return false;
			}
			if (BuildCostModelAfter != other.BuildCostModelAfter)
			{
				return false;
			}
			if (InferShapes != other.InferShapes)
			{
				return false;
			}
			if (PlacePrunedGraph != other.PlacePrunedGraph)
			{
				return false;
			}
			if (EnableBfloat16Sendrecv != other.EnableBfloat16Sendrecv)
			{
				return false;
			}
			if (TimelineStep != other.TimelineStep)
			{
				return false;
			}
			if (!object.Equals(RewriteOptions, other.RewriteOptions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (EnableRecvScheduling)
			{
				num ^= EnableRecvScheduling.GetHashCode();
			}
			if (optimizerOptions_ != null)
			{
				num ^= OptimizerOptions.GetHashCode();
			}
			if (BuildCostModel != 0L)
			{
				num ^= BuildCostModel.GetHashCode();
			}
			if (BuildCostModelAfter != 0L)
			{
				num ^= BuildCostModelAfter.GetHashCode();
			}
			if (InferShapes)
			{
				num ^= InferShapes.GetHashCode();
			}
			if (PlacePrunedGraph)
			{
				num ^= PlacePrunedGraph.GetHashCode();
			}
			if (EnableBfloat16Sendrecv)
			{
				num ^= EnableBfloat16Sendrecv.GetHashCode();
			}
			if (TimelineStep != 0)
			{
				num ^= TimelineStep.GetHashCode();
			}
			if (rewriteOptions_ != null)
			{
				num ^= RewriteOptions.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (EnableRecvScheduling)
			{
				output.WriteRawTag((byte)16);
				output.WriteBool(EnableRecvScheduling);
			}
			if (optimizerOptions_ != null)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)OptimizerOptions);
			}
			if (BuildCostModel != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(BuildCostModel);
			}
			if (InferShapes)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(InferShapes);
			}
			if (PlacePrunedGraph)
			{
				output.WriteRawTag((byte)48);
				output.WriteBool(PlacePrunedGraph);
			}
			if (EnableBfloat16Sendrecv)
			{
				output.WriteRawTag((byte)56);
				output.WriteBool(EnableBfloat16Sendrecv);
			}
			if (TimelineStep != 0)
			{
				output.WriteRawTag((byte)64);
				output.WriteInt32(TimelineStep);
			}
			if (BuildCostModelAfter != 0L)
			{
				output.WriteRawTag((byte)72);
				output.WriteInt64(BuildCostModelAfter);
			}
			if (rewriteOptions_ != null)
			{
				output.WriteRawTag((byte)82);
				output.WriteMessage((IMessage)(object)RewriteOptions);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (EnableRecvScheduling)
			{
				num += 2;
			}
			if (optimizerOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)OptimizerOptions);
			}
			if (BuildCostModel != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(BuildCostModel);
			}
			if (BuildCostModelAfter != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(BuildCostModelAfter);
			}
			if (InferShapes)
			{
				num += 2;
			}
			if (PlacePrunedGraph)
			{
				num += 2;
			}
			if (EnableBfloat16Sendrecv)
			{
				num += 2;
			}
			if (TimelineStep != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(TimelineStep);
			}
			if (rewriteOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)RewriteOptions);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(GraphOptions other)
		{
			if (other == null)
			{
				return;
			}
			if (other.EnableRecvScheduling)
			{
				EnableRecvScheduling = other.EnableRecvScheduling;
			}
			if (other.optimizerOptions_ != null)
			{
				if (optimizerOptions_ == null)
				{
					OptimizerOptions = new OptimizerOptions();
				}
				OptimizerOptions.MergeFrom(other.OptimizerOptions);
			}
			if (other.BuildCostModel != 0L)
			{
				BuildCostModel = other.BuildCostModel;
			}
			if (other.BuildCostModelAfter != 0L)
			{
				BuildCostModelAfter = other.BuildCostModelAfter;
			}
			if (other.InferShapes)
			{
				InferShapes = other.InferShapes;
			}
			if (other.PlacePrunedGraph)
			{
				PlacePrunedGraph = other.PlacePrunedGraph;
			}
			if (other.EnableBfloat16Sendrecv)
			{
				EnableBfloat16Sendrecv = other.EnableBfloat16Sendrecv;
			}
			if (other.TimelineStep != 0)
			{
				TimelineStep = other.TimelineStep;
			}
			if (other.rewriteOptions_ != null)
			{
				if (rewriteOptions_ == null)
				{
					RewriteOptions = new RewriterConfig();
				}
				RewriteOptions.MergeFrom(other.RewriteOptions);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 16u:
					EnableRecvScheduling = input.ReadBool();
					break;
				case 26u:
					if (optimizerOptions_ == null)
					{
						OptimizerOptions = new OptimizerOptions();
					}
					input.ReadMessage((IMessage)(object)OptimizerOptions);
					break;
				case 32u:
					BuildCostModel = input.ReadInt64();
					break;
				case 40u:
					InferShapes = input.ReadBool();
					break;
				case 48u:
					PlacePrunedGraph = input.ReadBool();
					break;
				case 56u:
					EnableBfloat16Sendrecv = input.ReadBool();
					break;
				case 64u:
					TimelineStep = input.ReadInt32();
					break;
				case 72u:
					BuildCostModelAfter = input.ReadInt64();
					break;
				case 82u:
					if (rewriteOptions_ == null)
					{
						RewriteOptions = new RewriterConfig();
					}
					input.ReadMessage((IMessage)(object)RewriteOptions);
					break;
				}
			}
		}
	}
	public sealed class ThreadPoolOptionProto : IMessage<ThreadPoolOptionProto>, IMessage, IEquatable<ThreadPoolOptionProto>, IDeepCloneable<ThreadPoolOptionProto>
	{
		private static readonly MessageParser<ThreadPoolOptionProto> _parser = new MessageParser<ThreadPoolOptionProto>((Func<ThreadPoolOptionProto>)(() => new ThreadPoolOptionProto()));

		private UnknownFieldSet _unknownFields;

		public const int NumThreadsFieldNumber = 1;

		private int numThreads_;

		public const int GlobalNameFieldNumber = 2;

		private string globalName_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<ThreadPoolOptionProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int NumThreads
		{
			get
			{
				return numThreads_;
			}
			set
			{
				numThreads_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string GlobalName
		{
			get
			{
				return globalName_;
			}
			set
			{
				globalName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public ThreadPoolOptionProto()
		{
		}

		[DebuggerNonUserCode]
		public ThreadPoolOptionProto(ThreadPoolOptionProto other)
			: this()
		{
			numThreads_ = other.numThreads_;
			globalName_ = other.globalName_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ThreadPoolOptionProto Clone()
		{
			return new ThreadPoolOptionProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ThreadPoolOptionProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(ThreadPoolOptionProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (NumThreads != other.NumThreads)
			{
				return false;
			}
			if (GlobalName != other.GlobalName)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (NumThreads != 0)
			{
				num ^= NumThreads.GetHashCode();
			}
			if (GlobalName.Length != 0)
			{
				num ^= GlobalName.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (NumThreads != 0)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt32(NumThreads);
			}
			if (GlobalName.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(GlobalName);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (NumThreads != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(NumThreads);
			}
			if (GlobalName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(GlobalName);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ThreadPoolOptionProto other)
		{
			if (other != null)
			{
				if (other.NumThreads != 0)
				{
					NumThreads = other.NumThreads;
				}
				if (other.GlobalName.Length != 0)
				{
					GlobalName = other.GlobalName;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					NumThreads = input.ReadInt32();
					break;
				case 18u:
					GlobalName = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class RPCOptions : IMessage<RPCOptions>, IMessage, IEquatable<RPCOptions>, IDeepCloneable<RPCOptions>
	{
		private static readonly MessageParser<RPCOptions> _parser = new MessageParser<RPCOptions>((Func<RPCOptions>)(() => new RPCOptions()));

		private UnknownFieldSet _unknownFields;

		public const int UseRpcForInprocessMasterFieldNumber = 1;

		private bool useRpcForInprocessMaster_;

		public const int CompressionAlgorithmFieldNumber = 2;

		private string compressionAlgorithm_ = "";

		public const int CompressionLevelFieldNumber = 3;

		private int compressionLevel_;

		public const int CacheRpcResponseFieldNumber = 4;

		private bool cacheRpcResponse_;

		public const int DisableSessionConnectionSharingFieldNumber = 5;

		private bool disableSessionConnectionSharing_;

		public const int NumChannelsPerTargetFieldNumber = 6;

		private int numChannelsPerTarget_;

		[DebuggerNonUserCode]
		public static MessageParser<RPCOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public bool UseRpcForInprocessMaster
		{
			get
			{
				return useRpcForInprocessMaster_;
			}
			set
			{
				useRpcForInprocessMaster_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string CompressionAlgorithm
		{
			get
			{
				return compressionAlgorithm_;
			}
			set
			{
				compressionAlgorithm_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public int CompressionLevel
		{
			get
			{
				return compressionLevel_;
			}
			set
			{
				compressionLevel_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool CacheRpcResponse
		{
			get
			{
				return cacheRpcResponse_;
			}
			set
			{
				cacheRpcResponse_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool DisableSessionConnectionSharing
		{
			get
			{
				return disableSessionConnectionSharing_;
			}
			set
			{
				disableSessionConnectionSharing_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int NumChannelsPerTarget
		{
			get
			{
				return numChannelsPerTarget_;
			}
			set
			{
				numChannelsPerTarget_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RPCOptions()
		{
		}

		[DebuggerNonUserCode]
		public RPCOptions(RPCOptions other)
			: this()
		{
			useRpcForInprocessMaster_ = other.useRpcForInprocessMaster_;
			compressionAlgorithm_ = other.compressionAlgorithm_;
			compressionLevel_ = other.compressionLevel_;
			cacheRpcResponse_ = other.cacheRpcResponse_;
			disableSessionConnectionSharing_ = other.disableSessionConnectionSharing_;
			numChannelsPerTarget_ = other.numChannelsPerTarget_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RPCOptions Clone()
		{
			return new RPCOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RPCOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(RPCOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (UseRpcForInprocessMaster != other.UseRpcForInprocessMaster)
			{
				return false;
			}
			if (CompressionAlgorithm != other.CompressionAlgorithm)
			{
				return false;
			}
			if (CompressionLevel != other.CompressionLevel)
			{
				return false;
			}
			if (CacheRpcResponse != other.CacheRpcResponse)
			{
				return false;
			}
			if (DisableSessionConnectionSharing != other.DisableSessionConnectionSharing)
			{
				return false;
			}
			if (NumChannelsPerTarget != other.NumChannelsPerTarget)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (UseRpcForInprocessMaster)
			{
				num ^= UseRpcForInprocessMaster.GetHashCode();
			}
			if (CompressionAlgorithm.Length != 0)
			{
				num ^= CompressionAlgorithm.GetHashCode();
			}
			if (CompressionLevel != 0)
			{
				num ^= CompressionLevel.GetHashCode();
			}
			if (CacheRpcResponse)
			{
				num ^= CacheRpcResponse.GetHashCode();
			}
			if (DisableSessionConnectionSharing)
			{
				num ^= DisableSessionConnectionSharing.GetHashCode();
			}
			if (NumChannelsPerTarget != 0)
			{
				num ^= NumChannelsPerTarget.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (UseRpcForInprocessMaster)
			{
				output.WriteRawTag((byte)8);
				output.WriteBool(UseRpcForInprocessMaster);
			}
			if (CompressionAlgorithm.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(CompressionAlgorithm);
			}
			if (CompressionLevel != 0)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt32(CompressionLevel);
			}
			if (CacheRpcResponse)
			{
				output.WriteRawTag((byte)32);
				output.WriteBool(CacheRpcResponse);
			}
			if (DisableSessionConnectionSharing)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(DisableSessionConnectionSharing);
			}
			if (NumChannelsPerTarget != 0)
			{
				output.WriteRawTag((byte)48);
				output.WriteInt32(NumChannelsPerTarget);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (UseRpcForInprocessMaster)
			{
				num += 2;
			}
			if (CompressionAlgorithm.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(CompressionAlgorithm);
			}
			if (CompressionLevel != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(CompressionLevel);
			}
			if (CacheRpcResponse)
			{
				num += 2;
			}
			if (DisableSessionConnectionSharing)
			{
				num += 2;
			}
			if (NumChannelsPerTarget != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(NumChannelsPerTarget);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RPCOptions other)
		{
			if (other != null)
			{
				if (other.UseRpcForInprocessMaster)
				{
					UseRpcForInprocessMaster = other.UseRpcForInprocessMaster;
				}
				if (other.CompressionAlgorithm.Length != 0)
				{
					CompressionAlgorithm = other.CompressionAlgorithm;
				}
				if (other.CompressionLevel != 0)
				{
					CompressionLevel = other.CompressionLevel;
				}
				if (other.CacheRpcResponse)
				{
					CacheRpcResponse = other.CacheRpcResponse;
				}
				if (other.DisableSessionConnectionSharing)
				{
					DisableSessionConnectionSharing = other.DisableSessionConnectionSharing;
				}
				if (other.NumChannelsPerTarget != 0)
				{
					NumChannelsPerTarget = other.NumChannelsPerTarget;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					UseRpcForInprocessMaster = input.ReadBool();
					break;
				case 18u:
					CompressionAlgorithm = input.ReadString();
					break;
				case 24u:
					CompressionLevel = input.ReadInt32();
					break;
				case 32u:
					CacheRpcResponse = input.ReadBool();
					break;
				case 40u:
					DisableSessionConnectionSharing = input.ReadBool();
					break;
				case 48u:
					NumChannelsPerTarget = input.ReadInt32();
					break;
				}
			}
		}
	}
	public sealed class SessionMetadata : IMessage<SessionMetadata>, IMessage, IEquatable<SessionMetadata>, IDeepCloneable<SessionMetadata>
	{
		private static readonly MessageParser<SessionMetadata> _parser = new MessageParser<SessionMetadata>((Func<SessionMetadata>)(() => new SessionMetadata()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int VersionFieldNumber = 2;

		private long version_;

		[DebuggerNonUserCode]
		public static MessageParser<SessionMetadata> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long Version
		{
			get
			{
				return version_;
			}
			set
			{
				version_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SessionMetadata()
		{
		}

		[DebuggerNonUserCode]
		public SessionMetadata(SessionMetadata other)
			: this()
		{
			name_ = other.name_;
			version_ = other.version_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SessionMetadata Clone()
		{
			return new SessionMetadata(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SessionMetadata);
		}

		[DebuggerNonUserCode]
		public bool Equals(SessionMetadata other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Version != other.Version)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (Version != 0L)
			{
				num ^= Version.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (Version != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(Version);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (Version != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Version);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SessionMetadata other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.Version != 0L)
				{
					Version = other.Version;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 16u:
					Version = input.ReadInt64();
					break;
				}
			}
		}
	}
	public sealed class ConfigProto : IMessage<ConfigProto>, IMessage, IEquatable<ConfigProto>, IDeepCloneable<ConfigProto>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class Experimental : IMessage<Experimental>, IMessage, IEquatable<Experimental>, IDeepCloneable<Experimental>
			{
				[DebuggerNonUserCode]
				public static class Types
				{
					public enum MlirBridgeRollout
					{
						[OriginalName("MLIR_BRIDGE_ROLLOUT_UNSPECIFIED")]
						Unspecified,
						[OriginalName("MLIR_BRIDGE_ROLLOUT_ENABLED")]
						Enabled,
						[OriginalName("MLIR_BRIDGE_ROLLOUT_DISABLED")]
						Disabled,
						[OriginalName("MLIR_BRIDGE_ROLLOUT_SAFE_MODE_ENABLED")]
						SafeModeEnabled,
						[OriginalName("MLIR_BRIDGE_ROLLOUT_SAFE_MODE_FALLBACK_ENABLED")]
						SafeModeFallbackEnabled
					}
				}

				private static readonly MessageParser<Experimental> _parser = new MessageParser<Experimental>((Func<Experimental>)(() => new Experimental()));

				private UnknownFieldSet _unknownFields;

				public const int CollectiveGroupLeaderFieldNumber = 1;

				private string collectiveGroupLeader_ = "";

				public const int ExecutorTypeFieldNumber = 3;

				private string executorType_ = "";

				public const int RecvBufMaxChunkFieldNumber = 4;

				private int recvBufMaxChunk_;

				public const int UseNumaAffinityFieldNumber = 5;

				private bool useNumaAffinity_;

				public const int CollectiveDeterministicSequentialExecutionFieldNumber = 6;

				private bool collectiveDeterministicSequentialExecution_;

				public const int CollectiveNcclFieldNumber = 7;

				private bool collectiveNccl_;

				public const int ShareSessionStateInClusterspecPropagationFieldNumber = 8;

				private bool shareSessionStateInClusterspecPropagation_;

				public const int DisableThreadSpinningFieldNumber = 9;

				private bool disableThreadSpinning_;

				public const int ShareClusterDevicesInSessionFieldNumber = 10;

				private bool shareClusterDevicesInSession_;

				public const int SessionMetadataFieldNumber = 11;

				private SessionMetadata sessionMetadata_;

				public const int OptimizeForStaticGraphFieldNumber = 12;

				private bool optimizeForStaticGraph_;

				public const int EnableMlirBridgeFieldNumber = 13;

				private bool enableMlirBridge_;

				public const int MlirBridgeRolloutFieldNumber = 17;

				private Types.MlirBridgeRollout mlirBridgeRollout_;

				public const int EnableMlirGraphOptimizationFieldNumber = 16;

				private bool enableMlirGraphOptimization_;

				public const int DisableOutputPartitionGraphsFieldNumber = 14;

				private bool disableOutputPartitionGraphs_;

				public const int XlaFusionAutotunerThreshFieldNumber = 15;

				private long xlaFusionAutotunerThresh_;

				public const int UseTfrtFieldNumber = 18;

				private bool useTfrt_;

				public const int DisableFunctionalOpsLoweringFieldNumber = 21;

				private bool disableFunctionalOpsLowering_;

				public const int XlaPreferSingleGraphClusterFieldNumber = 22;

				private bool xlaPreferSingleGraphCluster_;

				public const int CoordinationConfigFieldNumber = 23;

				private CoordinationServiceConfig coordinationConfig_;

				[DebuggerNonUserCode]
				public static MessageParser<Experimental> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => ConfigProto.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string CollectiveGroupLeader
				{
					get
					{
						return collectiveGroupLeader_;
					}
					set
					{
						collectiveGroupLeader_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string ExecutorType
				{
					get
					{
						return executorType_;
					}
					set
					{
						executorType_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public int RecvBufMaxChunk
				{
					get
					{
						return recvBufMaxChunk_;
					}
					set
					{
						recvBufMaxChunk_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool UseNumaAffinity
				{
					get
					{
						return useNumaAffinity_;
					}
					set
					{
						useNumaAffinity_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool CollectiveDeterministicSequentialExecution
				{
					get
					{
						return collectiveDeterministicSequentialExecution_;
					}
					set
					{
						collectiveDeterministicSequentialExecution_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool CollectiveNccl
				{
					get
					{
						return collectiveNccl_;
					}
					set
					{
						collectiveNccl_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool ShareSessionStateInClusterspecPropagation
				{
					get
					{
						return shareSessionStateInClusterspecPropagation_;
					}
					set
					{
						shareSessionStateInClusterspecPropagation_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool DisableThreadSpinning
				{
					get
					{
						return disableThreadSpinning_;
					}
					set
					{
						disableThreadSpinning_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool ShareClusterDevicesInSession
				{
					get
					{
						return shareClusterDevicesInSession_;
					}
					set
					{
						shareClusterDevicesInSession_ = value;
					}
				}

				[DebuggerNonUserCode]
				public SessionMetadata SessionMetadata
				{
					get
					{
						return sessionMetadata_;
					}
					set
					{
						sessionMetadata_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool OptimizeForStaticGraph
				{
					get
					{
						return optimizeForStaticGraph_;
					}
					set
					{
						optimizeForStaticGraph_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool EnableMlirBridge
				{
					get
					{
						return enableMlirBridge_;
					}
					set
					{
						enableMlirBridge_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Types.MlirBridgeRollout MlirBridgeRollout
				{
					get
					{
						return mlirBridgeRollout_;
					}
					set
					{
						mlirBridgeRollout_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool EnableMlirGraphOptimization
				{
					get
					{
						return enableMlirGraphOptimization_;
					}
					set
					{
						enableMlirGraphOptimization_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool DisableOutputPartitionGraphs
				{
					get
					{
						return disableOutputPartitionGraphs_;
					}
					set
					{
						disableOutputPartitionGraphs_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long XlaFusionAutotunerThresh
				{
					get
					{
						return xlaFusionAutotunerThresh_;
					}
					set
					{
						xlaFusionAutotunerThresh_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool UseTfrt
				{
					get
					{
						return useTfrt_;
					}
					set
					{
						useTfrt_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool DisableFunctionalOpsLowering
				{
					get
					{
						return disableFunctionalOpsLowering_;
					}
					set
					{
						disableFunctionalOpsLowering_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool XlaPreferSingleGraphCluster
				{
					get
					{
						return xlaPreferSingleGraphCluster_;
					}
					set
					{
						xlaPreferSingleGraphCluster_ = value;
					}
				}

				[DebuggerNonUserCode]
				public CoordinationServiceConfig CoordinationConfig
				{
					get
					{
						return coordinationConfig_;
					}
					set
					{
						coordinationConfig_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Experimental()
				{
				}

				[DebuggerNonUserCode]
				public Experimental(Experimental other)
					: this()
				{
					collectiveGroupLeader_ = other.collectiveGroupLeader_;
					executorType_ = other.executorType_;
					recvBufMaxChunk_ = other.recvBufMaxChunk_;
					useNumaAffinity_ = other.useNumaAffinity_;
					collectiveDeterministicSequentialExecution_ = other.collectiveDeterministicSequentialExecution_;
					collectiveNccl_ = other.collectiveNccl_;
					shareSessionStateInClusterspecPropagation_ = other.shareSessionStateInClusterspecPropagation_;
					disableThreadSpinning_ = other.disableThreadSpinning_;
					shareClusterDevicesInSession_ = other.shareClusterDevicesInSession_;
					sessionMetadata_ = ((other.sessionMetadata_ != null) ? other.sessionMetadata_.Clone() : null);
					optimizeForStaticGraph_ = other.optimizeForStaticGraph_;
					enableMlirBridge_ = other.enableMlirBridge_;
					mlirBridgeRollout_ = other.mlirBridgeRollout_;
					enableMlirGraphOptimization_ = other.enableMlirGraphOptimization_;
					disableOutputPartitionGraphs_ = other.disableOutputPartitionGraphs_;
					xlaFusionAutotunerThresh_ = other.xlaFusionAutotunerThresh_;
					useTfrt_ = other.useTfrt_;
					disableFunctionalOpsLowering_ = other.disableFunctionalOpsLowering_;
					xlaPreferSingleGraphCluster_ = other.xlaPreferSingleGraphCluster_;
					coordinationConfig_ = ((other.coordinationConfig_ != null) ? other.coordinationConfig_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Experimental Clone()
				{
					return new Experimental(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Experimental);
				}

				[DebuggerNonUserCode]
				public bool Equals(Experimental other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (CollectiveGroupLeader != other.CollectiveGroupLeader)
					{
						return false;
					}
					if (ExecutorType != other.ExecutorType)
					{
						return false;
					}
					if (RecvBufMaxChunk != other.RecvBufMaxChunk)
					{
						return false;
					}
					if (UseNumaAffinity != other.UseNumaAffinity)
					{
						return false;
					}
					if (CollectiveDeterministicSequentialExecution != other.CollectiveDeterministicSequentialExecution)
					{
						return false;
					}
					if (CollectiveNccl != other.CollectiveNccl)
					{
						return false;
					}
					if (ShareSessionStateInClusterspecPropagation != other.ShareSessionStateInClusterspecPropagation)
					{
						return false;
					}
					if (DisableThreadSpinning != other.DisableThreadSpinning)
					{
						return false;
					}
					if (ShareClusterDevicesInSession != other.ShareClusterDevicesInSession)
					{
						return false;
					}
					if (!object.Equals(SessionMetadata, other.SessionMetadata))
					{
						return false;
					}
					if (OptimizeForStaticGraph != other.OptimizeForStaticGraph)
					{
						return false;
					}
					if (EnableMlirBridge != other.EnableMlirBridge)
					{
						return false;
					}
					if (MlirBridgeRollout != other.MlirBridgeRollout)
					{
						return false;
					}
					if (EnableMlirGraphOptimization != other.EnableMlirGraphOptimization)
					{
						return false;
					}
					if (DisableOutputPartitionGraphs != other.DisableOutputPartitionGraphs)
					{
						return false;
					}
					if (XlaFusionAutotunerThresh != other.XlaFusionAutotunerThresh)
					{
						return false;
					}
					if (UseTfrt != other.UseTfrt)
					{
						return false;
					}
					if (DisableFunctionalOpsLowering != other.DisableFunctionalOpsLowering)
					{
						return false;
					}
					if (XlaPreferSingleGraphCluster != other.XlaPreferSingleGraphCluster)
					{
						return false;
					}
					if (!object.Equals(CoordinationConfig, other.CoordinationConfig))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (CollectiveGroupLeader.Length != 0)
					{
						num ^= CollectiveGroupLeader.GetHashCode();
					}
					if (ExecutorType.Length != 0)
					{
						num ^= ExecutorType.GetHashCode();
					}
					if (RecvBufMaxChunk != 0)
					{
						num ^= RecvBufMaxChunk.GetHashCode();
					}
					if (UseNumaAffinity)
					{
						num ^= UseNumaAffinity.GetHashCode();
					}
					if (CollectiveDeterministicSequentialExecution)
					{
						num ^= CollectiveDeterministicSequentialExecution.GetHashCode();
					}
					if (CollectiveNccl)
					{
						num ^= CollectiveNccl.GetHashCode();
					}
					if (ShareSessionStateInClusterspecPropagation)
					{
						num ^= ShareSessionStateInClusterspecPropagation.GetHashCode();
					}
					if (DisableThreadSpinning)
					{
						num ^= DisableThreadSpinning.GetHashCode();
					}
					if (ShareClusterDevicesInSession)
					{
						num ^= ShareClusterDevicesInSession.GetHashCode();
					}
					if (sessionMetadata_ != null)
					{
						num ^= SessionMetadata.GetHashCode();
					}
					if (OptimizeForStaticGraph)
					{
						num ^= OptimizeForStaticGraph.GetHashCode();
					}
					if (EnableMlirBridge)
					{
						num ^= EnableMlirBridge.GetHashCode();
					}
					if (MlirBridgeRollout != Types.MlirBridgeRollout.Unspecified)
					{
						num ^= MlirBridgeRollout.GetHashCode();
					}
					if (EnableMlirGraphOptimization)
					{
						num ^= EnableMlirGraphOptimization.GetHashCode();
					}
					if (DisableOutputPartitionGraphs)
					{
						num ^= DisableOutputPartitionGraphs.GetHashCode();
					}
					if (XlaFusionAutotunerThresh != 0L)
					{
						num ^= XlaFusionAutotunerThresh.GetHashCode();
					}
					if (UseTfrt)
					{
						num ^= UseTfrt.GetHashCode();
					}
					if (DisableFunctionalOpsLowering)
					{
						num ^= DisableFunctionalOpsLowering.GetHashCode();
					}
					if (XlaPreferSingleGraphCluster)
					{
						num ^= XlaPreferSingleGraphCluster.GetHashCode();
					}
					if (coordinationConfig_ != null)
					{
						num ^= CoordinationConfig.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (CollectiveGroupLeader.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(CollectiveGroupLeader);
					}
					if (ExecutorType.Length != 0)
					{
						output.WriteRawTag((byte)26);
						output.WriteString(ExecutorType);
					}
					if (RecvBufMaxChunk != 0)
					{
						output.WriteRawTag((byte)32);
						output.WriteInt32(RecvBufMaxChunk);
					}
					if (UseNumaAffinity)
					{
						output.WriteRawTag((byte)40);
						output.WriteBool(UseNumaAffinity);
					}
					if (CollectiveDeterministicSequentialExecution)
					{
						output.WriteRawTag((byte)48);
						output.WriteBool(CollectiveDeterministicSequentialExecution);
					}
					if (CollectiveNccl)
					{
						output.WriteRawTag((byte)56);
						output.WriteBool(CollectiveNccl);
					}
					if (ShareSessionStateInClusterspecPropagation)
					{
						output.WriteRawTag((byte)64);
						output.WriteBool(ShareSessionStateInClusterspecPropagation);
					}
					if (DisableThreadSpinning)
					{
						output.WriteRawTag((byte)72);
						output.WriteBool(DisableThreadSpinning);
					}
					if (ShareClusterDevicesInSession)
					{
						output.WriteRawTag((byte)80);
						output.WriteBool(ShareClusterDevicesInSession);
					}
					if (sessionMetadata_ != null)
					{
						output.WriteRawTag((byte)90);
						output.WriteMessage((IMessage)(object)SessionMetadata);
					}
					if (OptimizeForStaticGraph)
					{
						output.WriteRawTag((byte)96);
						output.WriteBool(OptimizeForStaticGraph);
					}
					if (EnableMlirBridge)
					{
						output.WriteRawTag((byte)104);
						output.WriteBool(EnableMlirBridge);
					}
					if (DisableOutputPartitionGraphs)
					{
						output.WriteRawTag((byte)112);
						output.WriteBool(DisableOutputPartitionGraphs);
					}
					if (XlaFusionAutotunerThresh != 0L)
					{
						output.WriteRawTag((byte)120);
						output.WriteInt64(XlaFusionAutotunerThresh);
					}
					if (EnableMlirGraphOptimization)
					{
						output.WriteRawTag((byte)128, (byte)1);
						output.WriteBool(EnableMlirGraphOptimization);
					}
					if (MlirBridgeRollout != Types.MlirBridgeRollout.Unspecified)
					{
						output.WriteRawTag((byte)136, (byte)1);
						output.WriteEnum((int)MlirBridgeRollout);
					}
					if (UseTfrt)
					{
						output.WriteRawTag((byte)144, (byte)1);
						output.WriteBool(UseTfrt);
					}
					if (DisableFunctionalOpsLowering)
					{
						output.WriteRawTag((byte)168, (byte)1);
						output.WriteBool(DisableFunctionalOpsLowering);
					}
					if (XlaPreferSingleGraphCluster)
					{
						output.WriteRawTag((byte)176, (byte)1);
						output.WriteBool(XlaPreferSingleGraphCluster);
					}
					if (coordinationConfig_ != null)
					{
						output.WriteRawTag((byte)186, (byte)1);
						output.WriteMessage((IMessage)(object)CoordinationConfig);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (CollectiveGroupLeader.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(CollectiveGroupLeader);
					}
					if (ExecutorType.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(ExecutorType);
					}
					if (RecvBufMaxChunk != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(RecvBufMaxChunk);
					}
					if (UseNumaAffinity)
					{
						num += 2;
					}
					if (CollectiveDeterministicSequentialExecution)
					{
						num += 2;
					}
					if (CollectiveNccl)
					{
						num += 2;
					}
					if (ShareSessionStateInClusterspecPropagation)
					{
						num += 2;
					}
					if (DisableThreadSpinning)
					{
						num += 2;
					}
					if (ShareClusterDevicesInSession)
					{
						num += 2;
					}
					if (sessionMetadata_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)SessionMetadata);
					}
					if (OptimizeForStaticGraph)
					{
						num += 2;
					}
					if (EnableMlirBridge)
					{
						num += 2;
					}
					if (MlirBridgeRollout != Types.MlirBridgeRollout.Unspecified)
					{
						num += 2 + CodedOutputStream.ComputeEnumSize((int)MlirBridgeRollout);
					}
					if (EnableMlirGraphOptimization)
					{
						num += 3;
					}
					if (DisableOutputPartitionGraphs)
					{
						num += 2;
					}
					if (XlaFusionAutotunerThresh != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(XlaFusionAutotunerThresh);
					}
					if (UseTfrt)
					{
						num += 3;
					}
					if (DisableFunctionalOpsLowering)
					{
						num += 3;
					}
					if (XlaPreferSingleGraphCluster)
					{
						num += 3;
					}
					if (coordinationConfig_ != null)
					{
						num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CoordinationConfig);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Experimental other)
				{
					if (other == null)
					{
						return;
					}
					if (other.CollectiveGroupLeader.Length != 0)
					{
						CollectiveGroupLeader = other.CollectiveGroupLeader;
					}
					if (other.ExecutorType.Length != 0)
					{
						ExecutorType = other.ExecutorType;
					}
					if (other.RecvBufMaxChunk != 0)
					{
						RecvBufMaxChunk = other.RecvBufMaxChunk;
					}
					if (other.UseNumaAffinity)
					{
						UseNumaAffinity = other.UseNumaAffinity;
					}
					if (other.CollectiveDeterministicSequentialExecution)
					{
						CollectiveDeterministicSequentialExecution = other.CollectiveDeterministicSequentialExecution;
					}
					if (other.CollectiveNccl)
					{
						CollectiveNccl = other.CollectiveNccl;
					}
					if (other.ShareSessionStateInClusterspecPropagation)
					{
						ShareSessionStateInClusterspecPropagation = other.ShareSessionStateInClusterspecPropagation;
					}
					if (other.DisableThreadSpinning)
					{
						DisableThreadSpinning = other.DisableThreadSpinning;
					}
					if (other.ShareClusterDevicesInSession)
					{
						ShareClusterDevicesInSession = other.ShareClusterDevicesInSession;
					}
					if (other.sessionMetadata_ != null)
					{
						if (sessionMetadata_ == null)
						{
							SessionMetadata = new SessionMetadata();
						}
						SessionMetadata.MergeFrom(other.SessionMetadata);
					}
					if (other.OptimizeForStaticGraph)
					{
						OptimizeForStaticGraph = other.OptimizeForStaticGraph;
					}
					if (other.EnableMlirBridge)
					{
						EnableMlirBridge = other.EnableMlirBridge;
					}
					if (other.MlirBridgeRollout != Types.MlirBridgeRollout.Unspecified)
					{
						MlirBridgeRollout = other.MlirBridgeRollout;
					}
					if (other.EnableMlirGraphOptimization)
					{
						EnableMlirGraphOptimization = other.EnableMlirGraphOptimization;
					}
					if (other.DisableOutputPartitionGraphs)
					{
						DisableOutputPartitionGraphs = other.DisableOutputPartitionGraphs;
					}
					if (other.XlaFusionAutotunerThresh != 0L)
					{
						XlaFusionAutotunerThresh = other.XlaFusionAutotunerThresh;
					}
					if (other.UseTfrt)
					{
						UseTfrt = other.UseTfrt;
					}
					if (other.DisableFunctionalOpsLowering)
					{
						DisableFunctionalOpsLowering = other.DisableFunctionalOpsLowering;
					}
					if (other.XlaPreferSingleGraphCluster)
					{
						XlaPreferSingleGraphCluster = other.XlaPreferSingleGraphCluster;
					}
					if (other.coordinationConfig_ != null)
					{
						if (coordinationConfig_ == null)
						{
							CoordinationConfig = new CoordinationServiceConfig();
						}
						CoordinationConfig.MergeFrom(other.CoordinationConfig);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							CollectiveGroupLeader = input.ReadString();
							break;
						case 26u:
							ExecutorType = input.ReadString();
							break;
						case 32u:
							RecvBufMaxChunk = input.ReadInt32();
							break;
						case 40u:
							UseNumaAffinity = input.ReadBool();
							break;
						case 48u:
							CollectiveDeterministicSequentialExecution = input.ReadBool();
							break;
						case 56u:
							CollectiveNccl = input.ReadBool();
							break;
						case 64u:
							ShareSessionStateInClusterspecPropagation = input.ReadBool();
							break;
						case 72u:
							DisableThreadSpinning = input.ReadBool();
							break;
						case 80u:
							ShareClusterDevicesInSession = input.ReadBool();
							break;
						case 90u:
							if (sessionMetadata_ == null)
							{
								SessionMetadata = new SessionMetadata();
							}
							input.ReadMessage((IMessage)(object)SessionMetadata);
							break;
						case 96u:
							OptimizeForStaticGraph = input.ReadBool();
							break;
						case 104u:
							EnableMlirBridge = input.ReadBool();
							break;
						case 112u:
							DisableOutputPartitionGraphs = input.ReadBool();
							break;
						case 120u:
							XlaFusionAutotunerThresh = input.ReadInt64();
							break;
						case 128u:
							EnableMlirGraphOptimization = input.ReadBool();
							break;
						case 136u:
							MlirBridgeRollout = (Types.MlirBridgeRollout)input.ReadEnum();
							break;
						case 144u:
							UseTfrt = input.ReadBool();
							break;
						case 168u:
							DisableFunctionalOpsLowering = input.ReadBool();
							break;
						case 176u:
							XlaPreferSingleGraphCluster = input.ReadBool();
							break;
						case 186u:
							if (coordinationConfig_ == null)
							{
								CoordinationConfig = new CoordinationServiceConfig();
							}
							input.ReadMessage((IMessage)(object)CoordinationConfig);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<ConfigProto> _parser = new MessageParser<ConfigProto>((Func<ConfigProto>)(() => new ConfigProto()));

		private UnknownFieldSet _unknownFields;

		public const int DeviceCountFieldNumber = 1;

		private static readonly Codec<string, int> _map_deviceCount_codec = new Codec<string, int>(FieldCodec.ForString(10u, ""), FieldCodec.ForInt32(16u, 0), 10u);

		private readonly MapField<string, int> deviceCount_ = new MapField<string, int>();

		public const int IntraOpParallelismThreadsFieldNumber = 2;

		private int intraOpParallelismThreads_;

		public const int InterOpParallelismThreadsFieldNumber = 5;

		private int interOpParallelismThreads_;

		public const int UsePerSessionThreadsFieldNumber = 9;

		private bool usePerSessionThreads_;

		public const int SessionInterOpThreadPoolFieldNumber = 12;

		private static readonly FieldCodec<ThreadPoolOptionProto> _repeated_sessionInterOpThreadPool_codec = FieldCodec.ForMessage<ThreadPoolOptionProto>(98u, ThreadPoolOptionProto.Parser);

		private readonly RepeatedField<ThreadPoolOptionProto> sessionInterOpThreadPool_ = new RepeatedField<ThreadPoolOptionProto>();

		public const int PlacementPeriodFieldNumber = 3;

		private int placementPeriod_;

		public const int DeviceFiltersFieldNumber = 4;

		private static readonly FieldCodec<string> _repeated_deviceFilters_codec = FieldCodec.ForString(34u);

		private readonly RepeatedField<string> deviceFilters_ = new RepeatedField<string>();

		public const int GpuOptionsFieldNumber = 6;

		private GPUOptions gpuOptions_;

		public const int AllowSoftPlacementFieldNumber = 7;

		private bool allowSoftPlacement_;

		public const int LogDevicePlacementFieldNumber = 8;

		private bool logDevicePlacement_;

		public const int GraphOptionsFieldNumber = 10;

		private GraphOptions graphOptions_;

		public const int OperationTimeoutInMsFieldNumber = 11;

		private long operationTimeoutInMs_;

		public const int RpcOptionsFieldNumber = 13;

		private RPCOptions rpcOptions_;

		public const int ClusterDefFieldNumber = 14;

		private ClusterDef clusterDef_;

		public const int IsolateSessionStateFieldNumber = 15;

		private bool isolateSessionState_;

		public const int ShareClusterDevicesInSessionFieldNumber = 17;

		private bool shareClusterDevicesInSession_;

		public const int ExperimentalFieldNumber = 16;

		private Types.Experimental experimental_;

		[DebuggerNonUserCode]
		public static MessageParser<ConfigProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public MapField<string, int> DeviceCount => deviceCount_;

		[DebuggerNonUserCode]
		public int IntraOpParallelismThreads
		{
			get
			{
				return intraOpParallelismThreads_;
			}
			set
			{
				intraOpParallelismThreads_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int InterOpParallelismThreads
		{
			get
			{
				return interOpParallelismThreads_;
			}
			set
			{
				interOpParallelismThreads_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool UsePerSessionThreads
		{
			get
			{
				return usePerSessionThreads_;
			}
			set
			{
				usePerSessionThreads_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<ThreadPoolOptionProto> SessionInterOpThreadPool => sessionInterOpThreadPool_;

		[DebuggerNonUserCode]
		public int PlacementPeriod
		{
			get
			{
				return placementPeriod_;
			}
			set
			{
				placementPeriod_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> DeviceFilters => deviceFilters_;

		[DebuggerNonUserCode]
		public GPUOptions GpuOptions
		{
			get
			{
				return gpuOptions_;
			}
			set
			{
				gpuOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool AllowSoftPlacement
		{
			get
			{
				return allowSoftPlacement_;
			}
			set
			{
				allowSoftPlacement_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool LogDevicePlacement
		{
			get
			{
				return logDevicePlacement_;
			}
			set
			{
				logDevicePlacement_ = value;
			}
		}

		[DebuggerNonUserCode]
		public GraphOptions GraphOptions
		{
			get
			{
				return graphOptions_;
			}
			set
			{
				graphOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long OperationTimeoutInMs
		{
			get
			{
				return operationTimeoutInMs_;
			}
			set
			{
				operationTimeoutInMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RPCOptions RpcOptions
		{
			get
			{
				return rpcOptions_;
			}
			set
			{
				rpcOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public ClusterDef ClusterDef
		{
			get
			{
				return clusterDef_;
			}
			set
			{
				clusterDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool IsolateSessionState
		{
			get
			{
				return isolateSessionState_;
			}
			set
			{
				isolateSessionState_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool ShareClusterDevicesInSession
		{
			get
			{
				return shareClusterDevicesInSession_;
			}
			set
			{
				shareClusterDevicesInSession_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Experimental Experimental
		{
			get
			{
				return experimental_;
			}
			set
			{
				experimental_ = value;
			}
		}

		[DebuggerNonUserCode]
		public ConfigProto()
		{
		}

		[DebuggerNonUserCode]
		public ConfigProto(ConfigProto other)
			: this()
		{
			deviceCount_ = other.deviceCount_.Clone();
			intraOpParallelismThreads_ = other.intraOpParallelismThreads_;
			interOpParallelismThreads_ = other.interOpParallelismThreads_;
			usePerSessionThreads_ = other.usePerSessionThreads_;
			sessionInterOpThreadPool_ = other.sessionInterOpThreadPool_.Clone();
			placementPeriod_ = other.placementPeriod_;
			deviceFilters_ = other.deviceFilters_.Clone();
			gpuOptions_ = ((other.gpuOptions_ != null) ? other.gpuOptions_.Clone() : null);
			allowSoftPlacement_ = other.allowSoftPlacement_;
			logDevicePlacement_ = other.logDevicePlacement_;
			graphOptions_ = ((other.graphOptions_ != null) ? other.graphOptions_.Clone() : null);
			operationTimeoutInMs_ = other.operationTimeoutInMs_;
			rpcOptions_ = ((other.rpcOptions_ != null) ? other.rpcOptions_.Clone() : null);
			clusterDef_ = ((other.clusterDef_ != null) ? other.clusterDef_.Clone() : null);
			isolateSessionState_ = other.isolateSessionState_;
			shareClusterDevicesInSession_ = other.shareClusterDevicesInSession_;
			experimental_ = ((other.experimental_ != null) ? other.experimental_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ConfigProto Clone()
		{
			return new ConfigProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ConfigProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(ConfigProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!DeviceCount.Equals(other.DeviceCount))
			{
				return false;
			}
			if (IntraOpParallelismThreads != other.IntraOpParallelismThreads)
			{
				return false;
			}
			if (InterOpParallelismThreads != other.InterOpParallelismThreads)
			{
				return false;
			}
			if (UsePerSessionThreads != other.UsePerSessionThreads)
			{
				return false;
			}
			if (!sessionInterOpThreadPool_.Equals(other.sessionInterOpThreadPool_))
			{
				return false;
			}
			if (PlacementPeriod != other.PlacementPeriod)
			{
				return false;
			}
			if (!deviceFilters_.Equals(other.deviceFilters_))
			{
				return false;
			}
			if (!object.Equals(GpuOptions, other.GpuOptions))
			{
				return false;
			}
			if (AllowSoftPlacement != other.AllowSoftPlacement)
			{
				return false;
			}
			if (LogDevicePlacement != other.LogDevicePlacement)
			{
				return false;
			}
			if (!object.Equals(GraphOptions, other.GraphOptions))
			{
				return false;
			}
			if (OperationTimeoutInMs != other.OperationTimeoutInMs)
			{
				return false;
			}
			if (!object.Equals(RpcOptions, other.RpcOptions))
			{
				return false;
			}
			if (!object.Equals(ClusterDef, other.ClusterDef))
			{
				return false;
			}
			if (IsolateSessionState != other.IsolateSessionState)
			{
				return false;
			}
			if (ShareClusterDevicesInSession != other.ShareClusterDevicesInSession)
			{
				return false;
			}
			if (!object.Equals(Experimental, other.Experimental))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)DeviceCount).GetHashCode();
			if (IntraOpParallelismThreads != 0)
			{
				num ^= IntraOpParallelismThreads.GetHashCode();
			}
			if (InterOpParallelismThreads != 0)
			{
				num ^= InterOpParallelismThreads.GetHashCode();
			}
			if (UsePerSessionThreads)
			{
				num ^= UsePerSessionThreads.GetHashCode();
			}
			num ^= ((object)sessionInterOpThreadPool_).GetHashCode();
			if (PlacementPeriod != 0)
			{
				num ^= PlacementPeriod.GetHashCode();
			}
			num ^= ((object)deviceFilters_).GetHashCode();
			if (gpuOptions_ != null)
			{
				num ^= GpuOptions.GetHashCode();
			}
			if (AllowSoftPlacement)
			{
				num ^= AllowSoftPlacement.GetHashCode();
			}
			if (LogDevicePlacement)
			{
				num ^= LogDevicePlacement.GetHashCode();
			}
			if (graphOptions_ != null)
			{
				num ^= GraphOptions.GetHashCode();
			}
			if (OperationTimeoutInMs != 0L)
			{
				num ^= OperationTimeoutInMs.GetHashCode();
			}
			if (rpcOptions_ != null)
			{
				num ^= RpcOptions.GetHashCode();
			}
			if (clusterDef_ != null)
			{
				num ^= ClusterDef.GetHashCode();
			}
			if (IsolateSessionState)
			{
				num ^= IsolateSessionState.GetHashCode();
			}
			if (ShareClusterDevicesInSession)
			{
				num ^= ShareClusterDevicesInSession.GetHashCode();
			}
			if (experimental_ != null)
			{
				num ^= Experimental.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			deviceCount_.WriteTo(output, _map_deviceCount_codec);
			if (IntraOpParallelismThreads != 0)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt32(IntraOpParallelismThreads);
			}
			if (PlacementPeriod != 0)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt32(PlacementPeriod);
			}
			deviceFilters_.WriteTo(output, _repeated_deviceFilters_codec);
			if (InterOpParallelismThreads != 0)
			{
				output.WriteRawTag((byte)40);
				output.WriteInt32(InterOpParallelismThreads);
			}
			if (gpuOptions_ != null)
			{
				output.WriteRawTag((byte)50);
				output.WriteMessage((IMessage)(object)GpuOptions);
			}
			if (AllowSoftPlacement)
			{
				output.WriteRawTag((byte)56);
				output.WriteBool(AllowSoftPlacement);
			}
			if (LogDevicePlacement)
			{
				output.WriteRawTag((byte)64);
				output.WriteBool(LogDevicePlacement);
			}
			if (UsePerSessionThreads)
			{
				output.WriteRawTag((byte)72);
				output.WriteBool(UsePerSessionThreads);
			}
			if (graphOptions_ != null)
			{
				output.WriteRawTag((byte)82);
				output.WriteMessage((IMessage)(object)GraphOptions);
			}
			if (OperationTimeoutInMs != 0L)
			{
				output.WriteRawTag((byte)88);
				output.WriteInt64(OperationTimeoutInMs);
			}
			sessionInterOpThreadPool_.WriteTo(output, _repeated_sessionInterOpThreadPool_codec);
			if (rpcOptions_ != null)
			{
				output.WriteRawTag((byte)106);
				output.WriteMessage((IMessage)(object)RpcOptions);
			}
			if (clusterDef_ != null)
			{
				output.WriteRawTag((byte)114);
				output.WriteMessage((IMessage)(object)ClusterDef);
			}
			if (IsolateSessionState)
			{
				output.WriteRawTag((byte)120);
				output.WriteBool(IsolateSessionState);
			}
			if (experimental_ != null)
			{
				output.WriteRawTag((byte)130, (byte)1);
				output.WriteMessage((IMessage)(object)Experimental);
			}
			if (ShareClusterDevicesInSession)
			{
				output.WriteRawTag((byte)136, (byte)1);
				output.WriteBool(ShareClusterDevicesInSession);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += deviceCount_.CalculateSize(_map_deviceCount_codec);
			if (IntraOpParallelismThreads != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(IntraOpParallelismThreads);
			}
			if (InterOpParallelismThreads != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(InterOpParallelismThreads);
			}
			if (UsePerSessionThreads)
			{
				num += 2;
			}
			num += sessionInterOpThreadPool_.CalculateSize(_repeated_sessionInterOpThreadPool_codec);
			if (PlacementPeriod != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(PlacementPeriod);
			}
			num += deviceFilters_.CalculateSize(_repeated_deviceFilters_codec);
			if (gpuOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)GpuOptions);
			}
			if (AllowSoftPlacement)
			{
				num += 2;
			}
			if (LogDevicePlacement)
			{
				num += 2;
			}
			if (graphOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)GraphOptions);
			}
			if (OperationTimeoutInMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(OperationTimeoutInMs);
			}
			if (rpcOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)RpcOptions);
			}
			if (clusterDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ClusterDef);
			}
			if (IsolateSessionState)
			{
				num += 2;
			}
			if (ShareClusterDevicesInSession)
			{
				num += 3;
			}
			if (experimental_ != null)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Experimental);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ConfigProto other)
		{
			if (other == null)
			{
				return;
			}
			deviceCount_.Add((IDictionary<string, int>)other.deviceCount_);
			if (other.IntraOpParallelismThreads != 0)
			{
				IntraOpParallelismThreads = other.IntraOpParallelismThreads;
			}
			if (other.InterOpParallelismThreads != 0)
			{
				InterOpParallelismThreads = other.InterOpParallelismThreads;
			}
			if (other.UsePerSessionThreads)
			{
				UsePerSessionThreads = other.UsePerSessionThreads;
			}
			sessionInterOpThreadPool_.Add((IEnumerable<ThreadPoolOptionProto>)other.sessionInterOpThreadPool_);
			if (other.PlacementPeriod != 0)
			{
				PlacementPeriod = other.PlacementPeriod;
			}
			deviceFilters_.Add((IEnumerable<string>)other.deviceFilters_);
			if (other.gpuOptions_ != null)
			{
				if (gpuOptions_ == null)
				{
					GpuOptions = new GPUOptions();
				}
				GpuOptions.MergeFrom(other.GpuOptions);
			}
			if (other.AllowSoftPlacement)
			{
				AllowSoftPlacement = other.AllowSoftPlacement;
			}
			if (other.LogDevicePlacement)
			{
				LogDevicePlacement = other.LogDevicePlacement;
			}
			if (other.graphOptions_ != null)
			{
				if (graphOptions_ == null)
				{
					GraphOptions = new GraphOptions();
				}
				GraphOptions.MergeFrom(other.GraphOptions);
			}
			if (other.OperationTimeoutInMs != 0L)
			{
				OperationTimeoutInMs = other.OperationTimeoutInMs;
			}
			if (other.rpcOptions_ != null)
			{
				if (rpcOptions_ == null)
				{
					RpcOptions = new RPCOptions();
				}
				RpcOptions.MergeFrom(other.RpcOptions);
			}
			if (other.clusterDef_ != null)
			{
				if (clusterDef_ == null)
				{
					ClusterDef = new ClusterDef();
				}
				ClusterDef.MergeFrom(other.ClusterDef);
			}
			if (other.IsolateSessionState)
			{
				IsolateSessionState = other.IsolateSessionState;
			}
			if (other.ShareClusterDevicesInSession)
			{
				ShareClusterDevicesInSession = other.ShareClusterDevicesInSession;
			}
			if (other.experimental_ != null)
			{
				if (experimental_ == null)
				{
					Experimental = new Types.Experimental();
				}
				Experimental.MergeFrom(other.Experimental);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					deviceCount_.AddEntriesFrom(input, _map_deviceCount_codec);
					break;
				case 16u:
					IntraOpParallelismThreads = input.ReadInt32();
					break;
				case 24u:
					PlacementPeriod = input.ReadInt32();
					break;
				case 34u:
					deviceFilters_.AddEntriesFrom(input, _repeated_deviceFilters_codec);
					break;
				case 40u:
					InterOpParallelismThreads = input.ReadInt32();
					break;
				case 50u:
					if (gpuOptions_ == null)
					{
						GpuOptions = new GPUOptions();
					}
					input.ReadMessage((IMessage)(object)GpuOptions);
					break;
				case 56u:
					AllowSoftPlacement = input.ReadBool();
					break;
				case 64u:
					LogDevicePlacement = input.ReadBool();
					break;
				case 72u:
					UsePerSessionThreads = input.ReadBool();
					break;
				case 82u:
					if (graphOptions_ == null)
					{
						GraphOptions = new GraphOptions();
					}
					input.ReadMessage((IMessage)(object)GraphOptions);
					break;
				case 88u:
					OperationTimeoutInMs = input.ReadInt64();
					break;
				case 98u:
					sessionInterOpThreadPool_.AddEntriesFrom(input, _repeated_sessionInterOpThreadPool_codec);
					break;
				case 106u:
					if (rpcOptions_ == null)
					{
						RpcOptions = new RPCOptions();
					}
					input.ReadMessage((IMessage)(object)RpcOptions);
					break;
				case 114u:
					if (clusterDef_ == null)
					{
						ClusterDef = new ClusterDef();
					}
					input.ReadMessage((IMessage)(object)ClusterDef);
					break;
				case 120u:
					IsolateSessionState = input.ReadBool();
					break;
				case 130u:
					if (experimental_ == null)
					{
						Experimental = new Types.Experimental();
					}
					input.ReadMessage((IMessage)(object)Experimental);
					break;
				case 136u:
					ShareClusterDevicesInSession = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class RunOptions : IMessage<RunOptions>, IMessage, IEquatable<RunOptions>, IDeepCloneable<RunOptions>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum TraceLevel
			{
				[OriginalName("NO_TRACE")]
				NoTrace,
				[OriginalName("SOFTWARE_TRACE")]
				SoftwareTrace,
				[OriginalName("HARDWARE_TRACE")]
				HardwareTrace,
				[OriginalName("FULL_TRACE")]
				FullTrace
			}

			public sealed class Experimental : IMessage<Experimental>, IMessage, IEquatable<Experimental>, IDeepCloneable<Experimental>
			{
				[DebuggerNonUserCode]
				public static class Types
				{
					public sealed class RunHandlerPoolOptions : IMessage<RunHandlerPoolOptions>, IMessage, IEquatable<RunHandlerPoolOptions>, IDeepCloneable<RunHandlerPoolOptions>
					{
						private static readonly MessageParser<RunHandlerPoolOptions> _parser = new MessageParser<RunHandlerPoolOptions>((Func<RunHandlerPoolOptions>)(() => new RunHandlerPoolOptions()));

						private UnknownFieldSet _unknownFields;

						public const int PriorityFieldNumber = 1;

						private long priority_;

						[DebuggerNonUserCode]
						public static MessageParser<RunHandlerPoolOptions> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => Experimental.Descriptor.NestedTypes[0];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public long Priority
						{
							get
							{
								return priority_;
							}
							set
							{
								priority_ = value;
							}
						}

						[DebuggerNonUserCode]
						public RunHandlerPoolOptions()
						{
						}

						[DebuggerNonUserCode]
						public RunHandlerPoolOptions(RunHandlerPoolOptions other)
							: this()
						{
							priority_ = other.priority_;
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public RunHandlerPoolOptions Clone()
						{
							return new RunHandlerPoolOptions(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as RunHandlerPoolOptions);
						}

						[DebuggerNonUserCode]
						public bool Equals(RunHandlerPoolOptions other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (Priority != other.Priority)
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							if (Priority != 0L)
							{
								num ^= Priority.GetHashCode();
							}
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							if (Priority != 0L)
							{
								output.WriteRawTag((byte)8);
								output.WriteInt64(Priority);
							}
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							if (Priority != 0L)
							{
								num += 1 + CodedOutputStream.ComputeInt64Size(Priority);
							}
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(RunHandlerPoolOptions other)
						{
							if (other != null)
							{
								if (other.Priority != 0L)
								{
									Priority = other.Priority;
								}
								_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
							}
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								if (num != 8)
								{
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
								}
								else
								{
									Priority = input.ReadInt64();
								}
							}
						}
					}
				}

				private static readonly MessageParser<Experimental> _parser = new MessageParser<Experimental>((Func<Experimental>)(() => new Experimental()));

				private UnknownFieldSet _unknownFields;

				public const int CollectiveGraphKeyFieldNumber = 1;

				private long collectiveGraphKey_;

				public const int UseRunHandlerPoolFieldNumber = 2;

				private bool useRunHandlerPool_;

				public const int RunHandlerPoolOptionsFieldNumber = 3;

				private Types.RunHandlerPoolOptions runHandlerPoolOptions_;

				[DebuggerNonUserCode]
				public static MessageParser<Experimental> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => RunOptions.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public long CollectiveGraphKey
				{
					get
					{
						return collectiveGraphKey_;
					}
					set
					{
						collectiveGraphKey_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool UseRunHandlerPool
				{
					get
					{
						return useRunHandlerPool_;
					}
					set
					{
						useRunHandlerPool_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Types.RunHandlerPoolOptions RunHandlerPoolOptions
				{
					get
					{
						return runHandlerPoolOptions_;
					}
					set
					{
						runHandlerPoolOptions_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Experimental()
				{
				}

				[DebuggerNonUserCode]
				public Experimental(Experimental other)
					: this()
				{
					collectiveGraphKey_ = other.collectiveGraphKey_;
					useRunHandlerPool_ = other.useRunHandlerPool_;
					runHandlerPoolOptions_ = ((other.runHandlerPoolOptions_ != null) ? other.runHandlerPoolOptions_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Experimental Clone()
				{
					return new Experimental(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Experimental);
				}

				[DebuggerNonUserCode]
				public bool Equals(Experimental other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (CollectiveGraphKey != other.CollectiveGraphKey)
					{
						return false;
					}
					if (UseRunHandlerPool != other.UseRunHandlerPool)
					{
						return false;
					}
					if (!object.Equals(RunHandlerPoolOptions, other.RunHandlerPoolOptions))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (CollectiveGraphKey != 0L)
					{
						num ^= CollectiveGraphKey.GetHashCode();
					}
					if (UseRunHandlerPool)
					{
						num ^= UseRunHandlerPool.GetHashCode();
					}
					if (runHandlerPoolOptions_ != null)
					{
						num ^= RunHandlerPoolOptions.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (CollectiveGraphKey != 0L)
					{
						output.WriteRawTag((byte)8);
						output.WriteInt64(CollectiveGraphKey);
					}
					if (UseRunHandlerPool)
					{
						output.WriteRawTag((byte)16);
						output.WriteBool(UseRunHandlerPool);
					}
					if (runHandlerPoolOptions_ != null)
					{
						output.WriteRawTag((byte)26);
						output.WriteMessage((IMessage)(object)RunHandlerPoolOptions);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (CollectiveGraphKey != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(CollectiveGraphKey);
					}
					if (UseRunHandlerPool)
					{
						num += 2;
					}
					if (runHandlerPoolOptions_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)RunHandlerPoolOptions);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Experimental other)
				{
					if (other == null)
					{
						return;
					}
					if (other.CollectiveGraphKey != 0L)
					{
						CollectiveGraphKey = other.CollectiveGraphKey;
					}
					if (other.UseRunHandlerPool)
					{
						UseRunHandlerPool = other.UseRunHandlerPool;
					}
					if (other.runHandlerPoolOptions_ != null)
					{
						if (runHandlerPoolOptions_ == null)
						{
							RunHandlerPoolOptions = new Types.RunHandlerPoolOptions();
						}
						RunHandlerPoolOptions.MergeFrom(other.RunHandlerPoolOptions);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 8u:
							CollectiveGraphKey = input.ReadInt64();
							break;
						case 16u:
							UseRunHandlerPool = input.ReadBool();
							break;
						case 26u:
							if (runHandlerPoolOptions_ == null)
							{
								RunHandlerPoolOptions = new Types.RunHandlerPoolOptions();
							}
							input.ReadMessage((IMessage)(object)RunHandlerPoolOptions);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<RunOptions> _parser = new MessageParser<RunOptions>((Func<RunOptions>)(() => new RunOptions()));

		private UnknownFieldSet _unknownFields;

		public const int TraceLevelFieldNumber = 1;

		private Types.TraceLevel traceLevel_;

		public const int TimeoutInMsFieldNumber = 2;

		private long timeoutInMs_;

		public const int InterOpThreadPoolFieldNumber = 3;

		private int interOpThreadPool_;

		public const int OutputPartitionGraphsFieldNumber = 5;

		private bool outputPartitionGraphs_;

		public const int DebugOptionsFieldNumber = 6;

		private DebugOptions debugOptions_;

		public const int ReportTensorAllocationsUponOomFieldNumber = 7;

		private bool reportTensorAllocationsUponOom_;

		public const int ExperimentalFieldNumber = 8;

		private Types.Experimental experimental_;

		[DebuggerNonUserCode]
		public static MessageParser<RunOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.TraceLevel TraceLevel
		{
			get
			{
				return traceLevel_;
			}
			set
			{
				traceLevel_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long TimeoutInMs
		{
			get
			{
				return timeoutInMs_;
			}
			set
			{
				timeoutInMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int InterOpThreadPool
		{
			get
			{
				return interOpThreadPool_;
			}
			set
			{
				interOpThreadPool_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool OutputPartitionGraphs
		{
			get
			{
				return outputPartitionGraphs_;
			}
			set
			{
				outputPartitionGraphs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public DebugOptions DebugOptions
		{
			get
			{
				return debugOptions_;
			}
			set
			{
				debugOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool ReportTensorAllocationsUponOom
		{
			get
			{
				return reportTensorAllocationsUponOom_;
			}
			set
			{
				reportTensorAllocationsUponOom_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Experimental Experimental
		{
			get
			{
				return experimental_;
			}
			set
			{
				experimental_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RunOptions()
		{
		}

		[DebuggerNonUserCode]
		public RunOptions(RunOptions other)
			: this()
		{
			traceLevel_ = other.traceLevel_;
			timeoutInMs_ = other.timeoutInMs_;
			interOpThreadPool_ = other.interOpThreadPool_;
			outputPartitionGraphs_ = other.outputPartitionGraphs_;
			debugOptions_ = ((other.debugOptions_ != null) ? other.debugOptions_.Clone() : null);
			reportTensorAllocationsUponOom_ = other.reportTensorAllocationsUponOom_;
			experimental_ = ((other.experimental_ != null) ? other.experimental_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RunOptions Clone()
		{
			return new RunOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RunOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(RunOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TraceLevel != other.TraceLevel)
			{
				return false;
			}
			if (TimeoutInMs != other.TimeoutInMs)
			{
				return false;
			}
			if (InterOpThreadPool != other.InterOpThreadPool)
			{
				return false;
			}
			if (OutputPartitionGraphs != other.OutputPartitionGraphs)
			{
				return false;
			}
			if (!object.Equals(DebugOptions, other.DebugOptions))
			{
				return false;
			}
			if (ReportTensorAllocationsUponOom != other.ReportTensorAllocationsUponOom)
			{
				return false;
			}
			if (!object.Equals(Experimental, other.Experimental))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TraceLevel != Types.TraceLevel.NoTrace)
			{
				num ^= TraceLevel.GetHashCode();
			}
			if (TimeoutInMs != 0L)
			{
				num ^= TimeoutInMs.GetHashCode();
			}
			if (InterOpThreadPool != 0)
			{
				num ^= InterOpThreadPool.GetHashCode();
			}
			if (OutputPartitionGraphs)
			{
				num ^= OutputPartitionGraphs.GetHashCode();
			}
			if (debugOptions_ != null)
			{
				num ^= DebugOptions.GetHashCode();
			}
			if (ReportTensorAllocationsUponOom)
			{
				num ^= ReportTensorAllocationsUponOom.GetHashCode();
			}
			if (experimental_ != null)
			{
				num ^= Experimental.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TraceLevel != Types.TraceLevel.NoTrace)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)TraceLevel);
			}
			if (TimeoutInMs != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(TimeoutInMs);
			}
			if (InterOpThreadPool != 0)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt32(InterOpThreadPool);
			}
			if (OutputPartitionGraphs)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(OutputPartitionGraphs);
			}
			if (debugOptions_ != null)
			{
				output.WriteRawTag((byte)50);
				output.WriteMessage((IMessage)(object)DebugOptions);
			}
			if (ReportTensorAllocationsUponOom)
			{
				output.WriteRawTag((byte)56);
				output.WriteBool(ReportTensorAllocationsUponOom);
			}
			if (experimental_ != null)
			{
				output.WriteRawTag((byte)66);
				output.WriteMessage((IMessage)(object)Experimental);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TraceLevel != Types.TraceLevel.NoTrace)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)TraceLevel);
			}
			if (TimeoutInMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(TimeoutInMs);
			}
			if (InterOpThreadPool != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(InterOpThreadPool);
			}
			if (OutputPartitionGraphs)
			{
				num += 2;
			}
			if (debugOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)DebugOptions);
			}
			if (ReportTensorAllocationsUponOom)
			{
				num += 2;
			}
			if (experimental_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Experimental);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RunOptions other)
		{
			if (other == null)
			{
				return;
			}
			if (other.TraceLevel != Types.TraceLevel.NoTrace)
			{
				TraceLevel = other.TraceLevel;
			}
			if (other.TimeoutInMs != 0L)
			{
				TimeoutInMs = other.TimeoutInMs;
			}
			if (other.InterOpThreadPool != 0)
			{
				InterOpThreadPool = other.InterOpThreadPool;
			}
			if (other.OutputPartitionGraphs)
			{
				OutputPartitionGraphs = other.OutputPartitionGraphs;
			}
			if (other.debugOptions_ != null)
			{
				if (debugOptions_ == null)
				{
					DebugOptions = new DebugOptions();
				}
				DebugOptions.MergeFrom(other.DebugOptions);
			}
			if (other.ReportTensorAllocationsUponOom)
			{
				ReportTensorAllocationsUponOom = other.ReportTensorAllocationsUponOom;
			}
			if (other.experimental_ != null)
			{
				if (experimental_ == null)
				{
					Experimental = new Types.Experimental();
				}
				Experimental.MergeFrom(other.Experimental);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					TraceLevel = (Types.TraceLevel)input.ReadEnum();
					break;
				case 16u:
					TimeoutInMs = input.ReadInt64();
					break;
				case 24u:
					InterOpThreadPool = input.ReadInt32();
					break;
				case 40u:
					OutputPartitionGraphs = input.ReadBool();
					break;
				case 50u:
					if (debugOptions_ == null)
					{
						DebugOptions = new DebugOptions();
					}
					input.ReadMessage((IMessage)(object)DebugOptions);
					break;
				case 56u:
					ReportTensorAllocationsUponOom = input.ReadBool();
					break;
				case 66u:
					if (experimental_ == null)
					{
						Experimental = new Types.Experimental();
					}
					input.ReadMessage((IMessage)(object)Experimental);
					break;
				}
			}
		}
	}
	public sealed class RunMetadata : IMessage<RunMetadata>, IMessage, IEquatable<RunMetadata>, IDeepCloneable<RunMetadata>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class FunctionGraphs : IMessage<FunctionGraphs>, IMessage, IEquatable<FunctionGraphs>, IDeepCloneable<FunctionGraphs>
			{
				private static readonly MessageParser<FunctionGraphs> _parser = new MessageParser<FunctionGraphs>((Func<FunctionGraphs>)(() => new FunctionGraphs()));

				private UnknownFieldSet _unknownFields;

				public const int PartitionGraphsFieldNumber = 1;

				private static readonly FieldCodec<GraphDef> _repeated_partitionGraphs_codec = FieldCodec.ForMessage<GraphDef>(10u, GraphDef.Parser);

				private readonly RepeatedField<GraphDef> partitionGraphs_ = new RepeatedField<GraphDef>();

				public const int PreOptimizationGraphFieldNumber = 2;

				private GraphDef preOptimizationGraph_;

				public const int PostOptimizationGraphFieldNumber = 3;

				private GraphDef postOptimizationGraph_;

				[DebuggerNonUserCode]
				public static MessageParser<FunctionGraphs> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => RunMetadata.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<GraphDef> PartitionGraphs => partitionGraphs_;

				[DebuggerNonUserCode]
				public GraphDef PreOptimizationGraph
				{
					get
					{
						return preOptimizationGraph_;
					}
					set
					{
						preOptimizationGraph_ = value;
					}
				}

				[DebuggerNonUserCode]
				public GraphDef PostOptimizationGraph
				{
					get
					{
						return postOptimizationGraph_;
					}
					set
					{
						postOptimizationGraph_ = value;
					}
				}

				[DebuggerNonUserCode]
				public FunctionGraphs()
				{
				}

				[DebuggerNonUserCode]
				public FunctionGraphs(FunctionGraphs other)
					: this()
				{
					partitionGraphs_ = other.partitionGraphs_.Clone();
					preOptimizationGraph_ = ((other.preOptimizationGraph_ != null) ? other.preOptimizationGraph_.Clone() : null);
					postOptimizationGraph_ = ((other.postOptimizationGraph_ != null) ? other.postOptimizationGraph_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public FunctionGraphs Clone()
				{
					return new FunctionGraphs(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as FunctionGraphs);
				}

				[DebuggerNonUserCode]
				public bool Equals(FunctionGraphs other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!partitionGraphs_.Equals(other.partitionGraphs_))
					{
						return false;
					}
					if (!object.Equals(PreOptimizationGraph, other.PreOptimizationGraph))
					{
						return false;
					}
					if (!object.Equals(PostOptimizationGraph, other.PostOptimizationGraph))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)partitionGraphs_).GetHashCode();
					if (preOptimizationGraph_ != null)
					{
						num ^= PreOptimizationGraph.GetHashCode();
					}
					if (postOptimizationGraph_ != null)
					{
						num ^= PostOptimizationGraph.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					partitionGraphs_.WriteTo(output, _repeated_partitionGraphs_codec);
					if (preOptimizationGraph_ != null)
					{
						output.WriteRawTag((byte)18);
						output.WriteMessage((IMessage)(object)PreOptimizationGraph);
					}
					if (postOptimizationGraph_ != null)
					{
						output.WriteRawTag((byte)26);
						output.WriteMessage((IMessage)(object)PostOptimizationGraph);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += partitionGraphs_.CalculateSize(_repeated_partitionGraphs_codec);
					if (preOptimizationGraph_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)PreOptimizationGraph);
					}
					if (postOptimizationGraph_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)PostOptimizationGraph);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(FunctionGraphs other)
				{
					if (other == null)
					{
						return;
					}
					partitionGraphs_.Add((IEnumerable<GraphDef>)other.partitionGraphs_);
					if (other.preOptimizationGraph_ != null)
					{
						if (preOptimizationGraph_ == null)
						{
							PreOptimizationGraph = new GraphDef();
						}
						PreOptimizationGraph.MergeFrom(other.PreOptimizationGraph);
					}
					if (other.postOptimizationGraph_ != null)
					{
						if (postOptimizationGraph_ == null)
						{
							PostOptimizationGraph = new GraphDef();
						}
						PostOptimizationGraph.MergeFrom(other.PostOptimizationGraph);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							partitionGraphs_.AddEntriesFrom(input, _repeated_partitionGraphs_codec);
							break;
						case 18u:
							if (preOptimizationGraph_ == null)
							{
								PreOptimizationGraph = new GraphDef();
							}
							input.ReadMessage((IMessage)(object)PreOptimizationGraph);
							break;
						case 26u:
							if (postOptimizationGraph_ == null)
							{
								PostOptimizationGraph = new GraphDef();
							}
							input.ReadMessage((IMessage)(object)PostOptimizationGraph);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<RunMetadata> _parser = new MessageParser<RunMetadata>((Func<RunMetadata>)(() => new RunMetadata()));

		private UnknownFieldSet _unknownFields;

		public const int StepStatsFieldNumber = 1;

		private StepStats stepStats_;

		public const int CostGraphFieldNumber = 2;

		private CostGraphDef costGraph_;

		public const int PartitionGraphsFieldNumber = 3;

		private static readonly FieldCodec<GraphDef> _repeated_partitionGraphs_codec = FieldCodec.ForMessage<GraphDef>(26u, GraphDef.Parser);

		private readonly RepeatedField<GraphDef> partitionGraphs_ = new RepeatedField<GraphDef>();

		public const int FunctionGraphsFieldNumber = 4;

		private static readonly FieldCodec<Types.FunctionGraphs> _repeated_functionGraphs_codec = FieldCodec.ForMessage<Types.FunctionGraphs>(34u, Types.FunctionGraphs.Parser);

		private readonly RepeatedField<Types.FunctionGraphs> functionGraphs_ = new RepeatedField<Types.FunctionGraphs>();

		[DebuggerNonUserCode]
		public static MessageParser<RunMetadata> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public StepStats StepStats
		{
			get
			{
				return stepStats_;
			}
			set
			{
				stepStats_ = value;
			}
		}

		[DebuggerNonUserCode]
		public CostGraphDef CostGraph
		{
			get
			{
				return costGraph_;
			}
			set
			{
				costGraph_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<GraphDef> PartitionGraphs => partitionGraphs_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.FunctionGraphs> FunctionGraphs => functionGraphs_;

		[DebuggerNonUserCode]
		public RunMetadata()
		{
		}

		[DebuggerNonUserCode]
		public RunMetadata(RunMetadata other)
			: this()
		{
			stepStats_ = ((other.stepStats_ != null) ? other.stepStats_.Clone() : null);
			costGraph_ = ((other.costGraph_ != null) ? other.costGraph_.Clone() : null);
			partitionGraphs_ = other.partitionGraphs_.Clone();
			functionGraphs_ = other.functionGraphs_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RunMetadata Clone()
		{
			return new RunMetadata(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RunMetadata);
		}

		[DebuggerNonUserCode]
		public bool Equals(RunMetadata other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(StepStats, other.StepStats))
			{
				return false;
			}
			if (!object.Equals(CostGraph, other.CostGraph))
			{
				return false;
			}
			if (!partitionGraphs_.Equals(other.partitionGraphs_))
			{
				return false;
			}
			if (!functionGraphs_.Equals(other.functionGraphs_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (stepStats_ != null)
			{
				num ^= StepStats.GetHashCode();
			}
			if (costGraph_ != null)
			{
				num ^= CostGraph.GetHashCode();
			}
			num ^= ((object)partitionGraphs_).GetHashCode();
			num ^= ((object)functionGraphs_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (stepStats_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)StepStats);
			}
			if (costGraph_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)CostGraph);
			}
			partitionGraphs_.WriteTo(output, _repeated_partitionGraphs_codec);
			functionGraphs_.WriteTo(output, _repeated_functionGraphs_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (stepStats_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)StepStats);
			}
			if (costGraph_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CostGraph);
			}
			num += partitionGraphs_.CalculateSize(_repeated_partitionGraphs_codec);
			num += functionGraphs_.CalculateSize(_repeated_functionGraphs_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RunMetadata other)
		{
			if (other == null)
			{
				return;
			}
			if (other.stepStats_ != null)
			{
				if (stepStats_ == null)
				{
					StepStats = new StepStats();
				}
				StepStats.MergeFrom(other.StepStats);
			}
			if (other.costGraph_ != null)
			{
				if (costGraph_ == null)
				{
					CostGraph = new CostGraphDef();
				}
				CostGraph.MergeFrom(other.CostGraph);
			}
			partitionGraphs_.Add((IEnumerable<GraphDef>)other.partitionGraphs_);
			functionGraphs_.Add((IEnumerable<Types.FunctionGraphs>)other.functionGraphs_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (stepStats_ == null)
					{
						StepStats = new StepStats();
					}
					input.ReadMessage((IMessage)(object)StepStats);
					break;
				case 18u:
					if (costGraph_ == null)
					{
						CostGraph = new CostGraphDef();
					}
					input.ReadMessage((IMessage)(object)CostGraph);
					break;
				case 26u:
					partitionGraphs_.AddEntriesFrom(input, _repeated_partitionGraphs_codec);
					break;
				case 34u:
					functionGraphs_.AddEntriesFrom(input, _repeated_functionGraphs_codec);
					break;
				}
			}
		}
	}
	public sealed class TensorConnection : IMessage<TensorConnection>, IMessage, IEquatable<TensorConnection>, IDeepCloneable<TensorConnection>
	{
		private static readonly MessageParser<TensorConnection> _parser = new MessageParser<TensorConnection>((Func<TensorConnection>)(() => new TensorConnection()));

		private UnknownFieldSet _unknownFields;

		public const int FromTensorFieldNumber = 1;

		private string fromTensor_ = "";

		public const int ToTensorFieldNumber = 2;

		private string toTensor_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<TensorConnection> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[9];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string FromTensor
		{
			get
			{
				return fromTensor_;
			}
			set
			{
				fromTensor_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string ToTensor
		{
			get
			{
				return toTensor_;
			}
			set
			{
				toTensor_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public TensorConnection()
		{
		}

		[DebuggerNonUserCode]
		public TensorConnection(TensorConnection other)
			: this()
		{
			fromTensor_ = other.fromTensor_;
			toTensor_ = other.toTensor_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TensorConnection Clone()
		{
			return new TensorConnection(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TensorConnection);
		}

		[DebuggerNonUserCode]
		public bool Equals(TensorConnection other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (FromTensor != other.FromTensor)
			{
				return false;
			}
			if (ToTensor != other.ToTensor)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (FromTensor.Length != 0)
			{
				num ^= FromTensor.GetHashCode();
			}
			if (ToTensor.Length != 0)
			{
				num ^= ToTensor.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (FromTensor.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(FromTensor);
			}
			if (ToTensor.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(ToTensor);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (FromTensor.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FromTensor);
			}
			if (ToTensor.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ToTensor);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TensorConnection other)
		{
			if (other != null)
			{
				if (other.FromTensor.Length != 0)
				{
					FromTensor = other.FromTensor;
				}
				if (other.ToTensor.Length != 0)
				{
					ToTensor = other.ToTensor;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					FromTensor = input.ReadString();
					break;
				case 18u:
					ToTensor = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class CallableOptions : IMessage<CallableOptions>, IMessage, IEquatable<CallableOptions>, IDeepCloneable<CallableOptions>
	{
		private static readonly MessageParser<CallableOptions> _parser = new MessageParser<CallableOptions>((Func<CallableOptions>)(() => new CallableOptions()));

		private UnknownFieldSet _unknownFields;

		public const int FeedFieldNumber = 1;

		private static readonly FieldCodec<string> _repeated_feed_codec = FieldCodec.ForString(10u);

		private readonly RepeatedField<string> feed_ = new RepeatedField<string>();

		public const int FetchFieldNumber = 2;

		private static readonly FieldCodec<string> _repeated_fetch_codec = FieldCodec.ForString(18u);

		private readonly RepeatedField<string> fetch_ = new RepeatedField<string>();

		public const int TargetFieldNumber = 3;

		private static readonly FieldCodec<string> _repeated_target_codec = FieldCodec.ForString(26u);

		private readonly RepeatedField<string> target_ = new RepeatedField<string>();

		public const int RunOptionsFieldNumber = 4;

		private RunOptions runOptions_;

		public const int TensorConnectionFieldNumber = 5;

		private static readonly FieldCodec<TensorConnection> _repeated_tensorConnection_codec = FieldCodec.ForMessage<TensorConnection>(42u, Tensorboard.TensorConnection.Parser);

		private readonly RepeatedField<TensorConnection> tensorConnection_ = new RepeatedField<TensorConnection>();

		public const int FeedDevicesFieldNumber = 6;

		private static readonly Codec<string, string> _map_feedDevices_codec = new Codec<string, string>(FieldCodec.ForString(10u, ""), FieldCodec.ForString(18u, ""), 50u);

		private readonly MapField<string, string> feedDevices_ = new MapField<string, string>();

		public const int FetchDevicesFieldNumber = 7;

		private static readonly Codec<string, string> _map_fetchDevices_codec = new Codec<string, string>(FieldCodec.ForString(10u, ""), FieldCodec.ForString(18u, ""), 58u);

		private readonly MapField<string, string> fetchDevices_ = new MapField<string, string>();

		public const int FetchSkipSyncFieldNumber = 8;

		private bool fetchSkipSync_;

		[DebuggerNonUserCode]
		public static MessageParser<CallableOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ConfigReflection.Descriptor.MessageTypes[10];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<string> Feed => feed_;

		[DebuggerNonUserCode]
		public RepeatedField<string> Fetch => fetch_;

		[DebuggerNonUserCode]
		public RepeatedField<string> Target => target_;

		[DebuggerNonUserCode]
		public RunOptions RunOptions
		{
			get
			{
				return runOptions_;
			}
			set
			{
				runOptions_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<TensorConnection> TensorConnection => tensorConnection_;

		[DebuggerNonUserCode]
		public MapField<string, string> FeedDevices => feedDevices_;

		[DebuggerNonUserCode]
		public MapField<string, string> FetchDevices => fetchDevices_;

		[DebuggerNonUserCode]
		public bool FetchSkipSync
		{
			get
			{
				return fetchSkipSync_;
			}
			set
			{
				fetchSkipSync_ = value;
			}
		}

		[DebuggerNonUserCode]
		public CallableOptions()
		{
		}

		[DebuggerNonUserCode]
		public CallableOptions(CallableOptions other)
			: this()
		{
			feed_ = other.feed_.Clone();
			fetch_ = other.fetch_.Clone();
			target_ = other.target_.Clone();
			runOptions_ = ((other.runOptions_ != null) ? other.runOptions_.Clone() : null);
			tensorConnection_ = other.tensorConnection_.Clone();
			feedDevices_ = other.feedDevices_.Clone();
			fetchDevices_ = other.fetchDevices_.Clone();
			fetchSkipSync_ = other.fetchSkipSync_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CallableOptions Clone()
		{
			return new CallableOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CallableOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(CallableOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!feed_.Equals(other.feed_))
			{
				return false;
			}
			if (!fetch_.Equals(other.fetch_))
			{
				return false;
			}
			if (!target_.Equals(other.target_))
			{
				return false;
			}
			if (!object.Equals(RunOptions, other.RunOptions))
			{
				return false;
			}
			if (!tensorConnection_.Equals(other.tensorConnection_))
			{
				return false;
			}
			if (!FeedDevices.Equals(other.FeedDevices))
			{
				return false;
			}
			if (!FetchDevices.Equals(other.FetchDevices))
			{
				return false;
			}
			if (FetchSkipSync != other.FetchSkipSync)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)feed_).GetHashCode();
			num ^= ((object)fetch_).GetHashCode();
			num ^= ((object)target_).GetHashCode();
			if (runOptions_ != null)
			{
				num ^= RunOptions.GetHashCode();
			}
			num ^= ((object)tensorConnection_).GetHashCode();
			num ^= ((object)FeedDevices).GetHashCode();
			num ^= ((object)FetchDevices).GetHashCode();
			if (FetchSkipSync)
			{
				num ^= FetchSkipSync.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			feed_.WriteTo(output, _repeated_feed_codec);
			fetch_.WriteTo(output, _repeated_fetch_codec);
			target_.WriteTo(output, _repeated_target_codec);
			if (runOptions_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)RunOptions);
			}
			tensorConnection_.WriteTo(output, _repeated_tensorConnection_codec);
			feedDevices_.WriteTo(output, _map_feedDevices_codec);
			fetchDevices_.WriteTo(output, _map_fetchDevices_codec);
			if (FetchSkipSync)
			{
				output.WriteRawTag((byte)64);
				output.WriteBool(FetchSkipSync);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += feed_.CalculateSize(_repeated_feed_codec);
			num += fetch_.CalculateSize(_repeated_fetch_codec);
			num += target_.CalculateSize(_repeated_target_codec);
			if (runOptions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)RunOptions);
			}
			num += tensorConnection_.CalculateSize(_repeated_tensorConnection_codec);
			num += feedDevices_.CalculateSize(_map_feedDevices_codec);
			num += fetchDevices_.CalculateSize(_map_fetchDevices_codec);
			if (FetchSkipSync)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CallableOptions other)
		{
			if (other == null)
			{
				return;
			}
			feed_.Add((IEnumerable<string>)other.feed_);
			fetch_.Add((IEnumerable<string>)other.fetch_);
			target_.Add((IEnumerable<string>)other.target_);
			if (other.runOptions_ != null)
			{
				if (runOptions_ == null)
				{
					RunOptions = new RunOptions();
				}
				RunOptions.MergeFrom(other.RunOptions);
			}
			tensorConnection_.Add((IEnumerable<TensorConnection>)other.tensorConnection_);
			feedDevices_.Add((IDictionary<string, string>)other.feedDevices_);
			fetchDevices_.Add((IDictionary<string, string>)other.fetchDevices_);
			if (other.FetchSkipSync)
			{
				FetchSkipSync = other.FetchSkipSync;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					feed_.AddEntriesFrom(input, _repeated_feed_codec);
					break;
				case 18u:
					fetch_.AddEntriesFrom(input, _repeated_fetch_codec);
					break;
				case 26u:
					target_.AddEntriesFrom(input, _repeated_target_codec);
					break;
				case 34u:
					if (runOptions_ == null)
					{
						RunOptions = new RunOptions();
					}
					input.ReadMessage((IMessage)(object)RunOptions);
					break;
				case 42u:
					tensorConnection_.AddEntriesFrom(input, _repeated_tensorConnection_codec);
					break;
				case 50u:
					feedDevices_.AddEntriesFrom(input, _map_feedDevices_codec);
					break;
				case 58u:
					fetchDevices_.AddEntriesFrom(input, _map_fetchDevices_codec);
					break;
				case 64u:
					FetchSkipSync = input.ReadBool();
					break;
				}
			}
		}
	}
	public static class CoordinationConfigReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static CoordinationConfigReflection()
		{
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CjJ0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vY29vcmRpbmF0aW9uX2NvbmZp" + "Zy5wcm90bxILdGVuc29yYm9hcmQinQIKGUNvb3JkaW5hdGlvblNlcnZpY2VD" + "b25maWcSFAoMc2VydmljZV90eXBlGAEgASgJEhYKDnNlcnZpY2VfbGVhZGVy" + "GAIgASgJEhsKE2VuYWJsZV9oZWFsdGhfY2hlY2sYAyABKAgSJgoeY2x1c3Rl" + "cl9yZWdpc3Rlcl90aW1lb3V0X2luX21zGAQgASgDEh8KF2hlYXJ0YmVhdF90" + "aW1lb3V0X2luX21zGAUgASgDEhgKEGNvb3JkaW5hdGVkX2pvYnMYBiADKAkS" + "Jgoec2h1dGRvd25fYmFycmllcl90aW1lb3V0X2luX21zGAcgASgDEioKImFn" + "ZW50X2Rlc3RydWN0aW9uX3dpdGhvdXRfc2h1dGRvd24YCCABKAhCV1pVZ2l0" + "aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9nby9j" + "b3JlL3Byb3RvYnVmL2Zvcl9jb3JlX3Byb3Rvc19nb19wcm90b2IGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(CoordinationServiceConfig), (MessageParser)(object)CoordinationServiceConfig.Parser, new string[8] { "ServiceType", "ServiceLeader", "EnableHealthCheck", "ClusterRegisterTimeoutInMs", "HeartbeatTimeoutInMs", "CoordinatedJobs", "ShutdownBarrierTimeoutInMs", "AgentDestructionWithoutShutdown" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class CoordinationServiceConfig : IMessage<CoordinationServiceConfig>, IMessage, IEquatable<CoordinationServiceConfig>, IDeepCloneable<CoordinationServiceConfig>
	{
		private static readonly MessageParser<CoordinationServiceConfig> _parser = new MessageParser<CoordinationServiceConfig>((Func<CoordinationServiceConfig>)(() => new CoordinationServiceConfig()));

		private UnknownFieldSet _unknownFields;

		public const int ServiceTypeFieldNumber = 1;

		private string serviceType_ = "";

		public const int ServiceLeaderFieldNumber = 2;

		private string serviceLeader_ = "";

		public const int EnableHealthCheckFieldNumber = 3;

		private bool enableHealthCheck_;

		public const int ClusterRegisterTimeoutInMsFieldNumber = 4;

		private long clusterRegisterTimeoutInMs_;

		public const int HeartbeatTimeoutInMsFieldNumber = 5;

		private long heartbeatTimeoutInMs_;

		public const int CoordinatedJobsFieldNumber = 6;

		private static readonly FieldCodec<string> _repeated_coordinatedJobs_codec = FieldCodec.ForString(50u);

		private readonly RepeatedField<string> coordinatedJobs_ = new RepeatedField<string>();

		public const int ShutdownBarrierTimeoutInMsFieldNumber = 7;

		private long shutdownBarrierTimeoutInMs_;

		public const int AgentDestructionWithoutShutdownFieldNumber = 8;

		private bool agentDestructionWithoutShutdown_;

		[DebuggerNonUserCode]
		public static MessageParser<CoordinationServiceConfig> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => CoordinationConfigReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string ServiceType
		{
			get
			{
				return serviceType_;
			}
			set
			{
				serviceType_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string ServiceLeader
		{
			get
			{
				return serviceLeader_;
			}
			set
			{
				serviceLeader_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public bool EnableHealthCheck
		{
			get
			{
				return enableHealthCheck_;
			}
			set
			{
				enableHealthCheck_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long ClusterRegisterTimeoutInMs
		{
			get
			{
				return clusterRegisterTimeoutInMs_;
			}
			set
			{
				clusterRegisterTimeoutInMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long HeartbeatTimeoutInMs
		{
			get
			{
				return heartbeatTimeoutInMs_;
			}
			set
			{
				heartbeatTimeoutInMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> CoordinatedJobs => coordinatedJobs_;

		[DebuggerNonUserCode]
		public long ShutdownBarrierTimeoutInMs
		{
			get
			{
				return shutdownBarrierTimeoutInMs_;
			}
			set
			{
				shutdownBarrierTimeoutInMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool AgentDestructionWithoutShutdown
		{
			get
			{
				return agentDestructionWithoutShutdown_;
			}
			set
			{
				agentDestructionWithoutShutdown_ = value;
			}
		}

		[DebuggerNonUserCode]
		public CoordinationServiceConfig()
		{
		}

		[DebuggerNonUserCode]
		public CoordinationServiceConfig(CoordinationServiceConfig other)
			: this()
		{
			serviceType_ = other.serviceType_;
			serviceLeader_ = other.serviceLeader_;
			enableHealthCheck_ = other.enableHealthCheck_;
			clusterRegisterTimeoutInMs_ = other.clusterRegisterTimeoutInMs_;
			heartbeatTimeoutInMs_ = other.heartbeatTimeoutInMs_;
			coordinatedJobs_ = other.coordinatedJobs_.Clone();
			shutdownBarrierTimeoutInMs_ = other.shutdownBarrierTimeoutInMs_;
			agentDestructionWithoutShutdown_ = other.agentDestructionWithoutShutdown_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CoordinationServiceConfig Clone()
		{
			return new CoordinationServiceConfig(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CoordinationServiceConfig);
		}

		[DebuggerNonUserCode]
		public bool Equals(CoordinationServiceConfig other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ServiceType != other.ServiceType)
			{
				return false;
			}
			if (ServiceLeader != other.ServiceLeader)
			{
				return false;
			}
			if (EnableHealthCheck != other.EnableHealthCheck)
			{
				return false;
			}
			if (ClusterRegisterTimeoutInMs != other.ClusterRegisterTimeoutInMs)
			{
				return false;
			}
			if (HeartbeatTimeoutInMs != other.HeartbeatTimeoutInMs)
			{
				return false;
			}
			if (!coordinatedJobs_.Equals(other.coordinatedJobs_))
			{
				return false;
			}
			if (ShutdownBarrierTimeoutInMs != other.ShutdownBarrierTimeoutInMs)
			{
				return false;
			}
			if (AgentDestructionWithoutShutdown != other.AgentDestructionWithoutShutdown)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (ServiceType.Length != 0)
			{
				num ^= ServiceType.GetHashCode();
			}
			if (ServiceLeader.Length != 0)
			{
				num ^= ServiceLeader.GetHashCode();
			}
			if (EnableHealthCheck)
			{
				num ^= EnableHealthCheck.GetHashCode();
			}
			if (ClusterRegisterTimeoutInMs != 0L)
			{
				num ^= ClusterRegisterTimeoutInMs.GetHashCode();
			}
			if (HeartbeatTimeoutInMs != 0L)
			{
				num ^= HeartbeatTimeoutInMs.GetHashCode();
			}
			num ^= ((object)coordinatedJobs_).GetHashCode();
			if (ShutdownBarrierTimeoutInMs != 0L)
			{
				num ^= ShutdownBarrierTimeoutInMs.GetHashCode();
			}
			if (AgentDestructionWithoutShutdown)
			{
				num ^= AgentDestructionWithoutShutdown.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (ServiceType.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(ServiceType);
			}
			if (ServiceLeader.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(ServiceLeader);
			}
			if (EnableHealthCheck)
			{
				output.WriteRawTag((byte)24);
				output.WriteBool(EnableHealthCheck);
			}
			if (ClusterRegisterTimeoutInMs != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(ClusterRegisterTimeoutInMs);
			}
			if (HeartbeatTimeoutInMs != 0L)
			{
				output.WriteRawTag((byte)40);
				output.WriteInt64(HeartbeatTimeoutInMs);
			}
			coordinatedJobs_.WriteTo(output, _repeated_coordinatedJobs_codec);
			if (ShutdownBarrierTimeoutInMs != 0L)
			{
				output.WriteRawTag((byte)56);
				output.WriteInt64(ShutdownBarrierTimeoutInMs);
			}
			if (AgentDestructionWithoutShutdown)
			{
				output.WriteRawTag((byte)64);
				output.WriteBool(AgentDestructionWithoutShutdown);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (ServiceType.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ServiceType);
			}
			if (ServiceLeader.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ServiceLeader);
			}
			if (EnableHealthCheck)
			{
				num += 2;
			}
			if (ClusterRegisterTimeoutInMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(ClusterRegisterTimeoutInMs);
			}
			if (HeartbeatTimeoutInMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(HeartbeatTimeoutInMs);
			}
			num += coordinatedJobs_.CalculateSize(_repeated_coordinatedJobs_codec);
			if (ShutdownBarrierTimeoutInMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(ShutdownBarrierTimeoutInMs);
			}
			if (AgentDestructionWithoutShutdown)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CoordinationServiceConfig other)
		{
			if (other != null)
			{
				if (other.ServiceType.Length != 0)
				{
					ServiceType = other.ServiceType;
				}
				if (other.ServiceLeader.Length != 0)
				{
					ServiceLeader = other.ServiceLeader;
				}
				if (other.EnableHealthCheck)
				{
					EnableHealthCheck = other.EnableHealthCheck;
				}
				if (other.ClusterRegisterTimeoutInMs != 0L)
				{
					ClusterRegisterTimeoutInMs = other.ClusterRegisterTimeoutInMs;
				}
				if (other.HeartbeatTimeoutInMs != 0L)
				{
					HeartbeatTimeoutInMs = other.HeartbeatTimeoutInMs;
				}
				coordinatedJobs_.Add((IEnumerable<string>)other.coordinatedJobs_);
				if (other.ShutdownBarrierTimeoutInMs != 0L)
				{
					ShutdownBarrierTimeoutInMs = other.ShutdownBarrierTimeoutInMs;
				}
				if (other.AgentDestructionWithoutShutdown)
				{
					AgentDestructionWithoutShutdown = other.AgentDestructionWithoutShutdown;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					ServiceType = input.ReadString();
					break;
				case 18u:
					ServiceLeader = input.ReadString();
					break;
				case 24u:
					EnableHealthCheck = input.ReadBool();
					break;
				case 32u:
					ClusterRegisterTimeoutInMs = input.ReadInt64();
					break;
				case 40u:
					HeartbeatTimeoutInMs = input.ReadInt64();
					break;
				case 50u:
					coordinatedJobs_.AddEntriesFrom(input, _repeated_coordinatedJobs_codec);
					break;
				case 56u:
					ShutdownBarrierTimeoutInMs = input.ReadInt64();
					break;
				case 64u:
					AgentDestructionWithoutShutdown = input.ReadBool();
					break;
				}
			}
		}
	}
	public static class CostGraphReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static CostGraphReflection()
		{
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Expected O, but got Unknown
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Expected O, but got Unknown
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vY29zdF9ncmFwaC5wcm90bxIL" + "dGVuc29yYm9hcmQaK3RlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90ZW5zb3Jf" + "c2hhcGUucHJvdG8aJHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90eXBlcy5w" + "cm90byLQBgoMQ29zdEdyYXBoRGVmEiwKBG5vZGUYASADKAsyHi50ZW5zb3Ji" + "b2FyZC5Db3N0R3JhcGhEZWYuTm9kZRI2CgRjb3N0GAIgAygLMigudGVuc29y" + "Ym9hcmQuQ29zdEdyYXBoRGVmLkFnZ3JlZ2F0ZWRDb3N0GqYFCgROb2RlEgwK" + "BG5hbWUYASABKAkSDgoGZGV2aWNlGAIgASgJEgoKAmlkGAMgASgFEjwKCmlu" + "cHV0X2luZm8YBCADKAsyKC50ZW5zb3Jib2FyZC5Db3N0R3JhcGhEZWYuTm9k" + "ZS5JbnB1dEluZm8SPgoLb3V0cHV0X2luZm8YBSADKAsyKS50ZW5zb3Jib2Fy" + "ZC5Db3N0R3JhcGhEZWYuTm9kZS5PdXRwdXRJbmZvEh0KFXRlbXBvcmFyeV9t" + "ZW1vcnlfc2l6ZRgGIAEoAxIeChZwZXJzaXN0ZW50X21lbW9yeV9zaXplGAwg" + "ASgDEiEKFWhvc3RfdGVtcF9tZW1vcnlfc2l6ZRgKIAEoA0ICGAESIwoXZGV2" + "aWNlX3RlbXBfbWVtb3J5X3NpemUYCyABKANCAhgBEikKHWRldmljZV9wZXJz" + "aXN0ZW50X21lbW9yeV9zaXplGBAgASgDQgIYARIUCgxjb21wdXRlX2Nvc3QY" + "CSABKAMSFAoMY29tcHV0ZV90aW1lGA4gASgDEhMKC21lbW9yeV90aW1lGA8g" + "ASgDEhAKCGlzX2ZpbmFsGAcgASgIEhUKDWNvbnRyb2xfaW5wdXQYCCADKAUS" + "EgoKaW5hY2N1cmF0ZRgRIAEoCBo7CglJbnB1dEluZm8SFgoOcHJlY2VkaW5n" + "X25vZGUYASABKAUSFgoOcHJlY2VkaW5nX3BvcnQYAiABKAUaiAEKCk91dHB1" + "dEluZm8SDAoEc2l6ZRgBIAEoAxIYChBhbGlhc19pbnB1dF9wb3J0GAIgASgD" + "EiwKBXNoYXBlGAMgASgLMh0udGVuc29yYm9hcmQuVGVuc29yU2hhcGVQcm90" + "bxIkCgVkdHlwZRgEIAEoDjIVLnRlbnNvcmJvYXJkLkRhdGFUeXBlGjEKDkFn" + "Z3JlZ2F0ZWRDb3N0EgwKBGNvc3QYASABKAISEQoJZGltZW5zaW9uGAIgASgJ" + "QoMBChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCD0Nvc3RHcmFwaFByb3Rv" + "c1ABWlFnaXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3Jm" + "bG93L2dvL2NvcmUvZnJhbWV3b3JrL2Nvc3RfZ3JhcGhfZ29fcHJvdG/4AQFi" + "BnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[2]
			{
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(CostGraphDef), (MessageParser)(object)CostGraphDef.Parser, new string[2] { "Node", "Cost" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
				{
					new GeneratedClrTypeInfo(typeof(CostGraphDef.Types.Node), (MessageParser)(object)CostGraphDef.Types.Node.Parser, new string[16]
					{
						"Name", "Device", "Id", "InputInfo", "OutputInfo", "TemporaryMemorySize", "PersistentMemorySize", "HostTempMemorySize", "DeviceTempMemorySize", "DevicePersistentMemorySize",
						"ComputeCost", "ComputeTime", "MemoryTime", "IsFinal", "ControlInput", "Inaccurate"
					}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
					{
						new GeneratedClrTypeInfo(typeof(CostGraphDef.Types.Node.Types.InputInfo), (MessageParser)(object)CostGraphDef.Types.Node.Types.InputInfo.Parser, new string[2] { "PrecedingNode", "PrecedingPort" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
						new GeneratedClrTypeInfo(typeof(CostGraphDef.Types.Node.Types.OutputInfo), (MessageParser)(object)CostGraphDef.Types.Node.Types.OutputInfo.Parser, new string[4] { "Size", "AliasInputPort", "Shape", "Dtype" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
					}),
					new GeneratedClrTypeInfo(typeof(CostGraphDef.Types.AggregatedCost), (MessageParser)(object)CostGraphDef.Types.AggregatedCost.Parser, new string[2] { "Cost", "Dimension" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				})
			}));
		}
	}
	public sealed class CostGraphDef : IMessage<CostGraphDef>, IMessage, IEquatable<CostGraphDef>, IDeepCloneable<CostGraphDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class Node : IMessage<Node>, IMessage, IEquatable<Node>, IDeepCloneable<Node>
			{
				[DebuggerNonUserCode]
				public static class Types
				{
					public sealed class InputInfo : IMessage<InputInfo>, IMessage, IEquatable<InputInfo>, IDeepCloneable<InputInfo>
					{
						private static readonly MessageParser<InputInfo> _parser = new MessageParser<InputInfo>((Func<InputInfo>)(() => new InputInfo()));

						private UnknownFieldSet _unknownFields;

						public const int PrecedingNodeFieldNumber = 1;

						private int precedingNode_;

						public const int PrecedingPortFieldNumber = 2;

						private int precedingPort_;

						[DebuggerNonUserCode]
						public static MessageParser<InputInfo> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => Node.Descriptor.NestedTypes[0];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public int PrecedingNode
						{
							get
							{
								return precedingNode_;
							}
							set
							{
								precedingNode_ = value;
							}
						}

						[DebuggerNonUserCode]
						public int PrecedingPort
						{
							get
							{
								return precedingPort_;
							}
							set
							{
								precedingPort_ = value;
							}
						}

						[DebuggerNonUserCode]
						public InputInfo()
						{
						}

						[DebuggerNonUserCode]
						public InputInfo(InputInfo other)
							: this()
						{
							precedingNode_ = other.precedingNode_;
							precedingPort_ = other.precedingPort_;
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public InputInfo Clone()
						{
							return new InputInfo(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as InputInfo);
						}

						[DebuggerNonUserCode]
						public bool Equals(InputInfo other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (PrecedingNode != other.PrecedingNode)
							{
								return false;
							}
							if (PrecedingPort != other.PrecedingPort)
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							if (PrecedingNode != 0)
							{
								num ^= PrecedingNode.GetHashCode();
							}
							if (PrecedingPort != 0)
							{
								num ^= PrecedingPort.GetHashCode();
							}
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							if (PrecedingNode != 0)
							{
								output.WriteRawTag((byte)8);
								output.WriteInt32(PrecedingNode);
							}
							if (PrecedingPort != 0)
							{
								output.WriteRawTag((byte)16);
								output.WriteInt32(PrecedingPort);
							}
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							if (PrecedingNode != 0)
							{
								num += 1 + CodedOutputStream.ComputeInt32Size(PrecedingNode);
							}
							if (PrecedingPort != 0)
							{
								num += 1 + CodedOutputStream.ComputeInt32Size(PrecedingPort);
							}
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(InputInfo other)
						{
							if (other != null)
							{
								if (other.PrecedingNode != 0)
								{
									PrecedingNode = other.PrecedingNode;
								}
								if (other.PrecedingPort != 0)
								{
									PrecedingPort = other.PrecedingPort;
								}
								_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
							}
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								switch (num)
								{
								default:
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
									break;
								case 8u:
									PrecedingNode = input.ReadInt32();
									break;
								case 16u:
									PrecedingPort = input.ReadInt32();
									break;
								}
							}
						}
					}

					public sealed class OutputInfo : IMessage<OutputInfo>, IMessage, IEquatable<OutputInfo>, IDeepCloneable<OutputInfo>
					{
						private static readonly MessageParser<OutputInfo> _parser = new MessageParser<OutputInfo>((Func<OutputInfo>)(() => new OutputInfo()));

						private UnknownFieldSet _unknownFields;

						public const int SizeFieldNumber = 1;

						private long size_;

						public const int AliasInputPortFieldNumber = 2;

						private long aliasInputPort_;

						public const int ShapeFieldNumber = 3;

						private TensorShapeProto shape_;

						public const int DtypeFieldNumber = 4;

						private DataType dtype_;

						[DebuggerNonUserCode]
						public static MessageParser<OutputInfo> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => Node.Descriptor.NestedTypes[1];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public long Size
						{
							get
							{
								return size_;
							}
							set
							{
								size_ = value;
							}
						}

						[DebuggerNonUserCode]
						public long AliasInputPort
						{
							get
							{
								return aliasInputPort_;
							}
							set
							{
								aliasInputPort_ = value;
							}
						}

						[DebuggerNonUserCode]
						public TensorShapeProto Shape
						{
							get
							{
								return shape_;
							}
							set
							{
								shape_ = value;
							}
						}

						[DebuggerNonUserCode]
						public DataType Dtype
						{
							get
							{
								return dtype_;
							}
							set
							{
								dtype_ = value;
							}
						}

						[DebuggerNonUserCode]
						public OutputInfo()
						{
						}

						[DebuggerNonUserCode]
						public OutputInfo(OutputInfo other)
							: this()
						{
							size_ = other.size_;
							aliasInputPort_ = other.aliasInputPort_;
							shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
							dtype_ = other.dtype_;
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public OutputInfo Clone()
						{
							return new OutputInfo(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as OutputInfo);
						}

						[DebuggerNonUserCode]
						public bool Equals(OutputInfo other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (Size != other.Size)
							{
								return false;
							}
							if (AliasInputPort != other.AliasInputPort)
							{
								return false;
							}
							if (!object.Equals(Shape, other.Shape))
							{
								return false;
							}
							if (Dtype != other.Dtype)
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							if (Size != 0L)
							{
								num ^= Size.GetHashCode();
							}
							if (AliasInputPort != 0L)
							{
								num ^= AliasInputPort.GetHashCode();
							}
							if (shape_ != null)
							{
								num ^= Shape.GetHashCode();
							}
							if (Dtype != DataType.DtInvalid)
							{
								num ^= Dtype.GetHashCode();
							}
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							if (Size != 0L)
							{
								output.WriteRawTag((byte)8);
								output.WriteInt64(Size);
							}
							if (AliasInputPort != 0L)
							{
								output.WriteRawTag((byte)16);
								output.WriteInt64(AliasInputPort);
							}
							if (shape_ != null)
							{
								output.WriteRawTag((byte)26);
								output.WriteMessage((IMessage)(object)Shape);
							}
							if (Dtype != DataType.DtInvalid)
							{
								output.WriteRawTag((byte)32);
								output.WriteEnum((int)Dtype);
							}
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							if (Size != 0L)
							{
								num += 1 + CodedOutputStream.ComputeInt64Size(Size);
							}
							if (AliasInputPort != 0L)
							{
								num += 1 + CodedOutputStream.ComputeInt64Size(AliasInputPort);
							}
							if (shape_ != null)
							{
								num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
							}
							if (Dtype != DataType.DtInvalid)
							{
								num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
							}
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(OutputInfo other)
						{
							if (other == null)
							{
								return;
							}
							if (other.Size != 0L)
							{
								Size = other.Size;
							}
							if (other.AliasInputPort != 0L)
							{
								AliasInputPort = other.AliasInputPort;
							}
							if (other.shape_ != null)
							{
								if (shape_ == null)
								{
									Shape = new TensorShapeProto();
								}
								Shape.MergeFrom(other.Shape);
							}
							if (other.Dtype != DataType.DtInvalid)
							{
								Dtype = other.Dtype;
							}
							_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								switch (num)
								{
								default:
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
									break;
								case 8u:
									Size = input.ReadInt64();
									break;
								case 16u:
									AliasInputPort = input.ReadInt64();
									break;
								case 26u:
									if (shape_ == null)
									{
										Shape = new TensorShapeProto();
									}
									input.ReadMessage((IMessage)(object)Shape);
									break;
								case 32u:
									Dtype = (DataType)input.ReadEnum();
									break;
								}
							}
						}
					}
				}

				private static readonly MessageParser<Node> _parser = new MessageParser<Node>((Func<Node>)(() => new Node()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int DeviceFieldNumber = 2;

				private string device_ = "";

				public const int IdFieldNumber = 3;

				private int id_;

				public const int InputInfoFieldNumber = 4;

				private static readonly FieldCodec<Types.InputInfo> _repeated_inputInfo_codec = FieldCodec.ForMessage<Types.InputInfo>(34u, Types.InputInfo.Parser);

				private readonly RepeatedField<Types.InputInfo> inputInfo_ = new RepeatedField<Types.InputInfo>();

				public const int OutputInfoFieldNumber = 5;

				private static readonly FieldCodec<Types.OutputInfo> _repeated_outputInfo_codec = FieldCodec.ForMessage<Types.OutputInfo>(42u, Types.OutputInfo.Parser);

				private readonly RepeatedField<Types.OutputInfo> outputInfo_ = new RepeatedField<Types.OutputInfo>();

				public const int TemporaryMemorySizeFieldNumber = 6;

				private long temporaryMemorySize_;

				public const int PersistentMemorySizeFieldNumber = 12;

				private long persistentMemorySize_;

				public const int HostTempMemorySizeFieldNumber = 10;

				private long hostTempMemorySize_;

				public const int DeviceTempMemorySizeFieldNumber = 11;

				private long deviceTempMemorySize_;

				public const int DevicePersistentMemorySizeFieldNumber = 16;

				private long devicePersistentMemorySize_;

				public const int ComputeCostFieldNumber = 9;

				private long computeCost_;

				public const int ComputeTimeFieldNumber = 14;

				private long computeTime_;

				public const int MemoryTimeFieldNumber = 15;

				private long memoryTime_;

				public const int IsFinalFieldNumber = 7;

				private bool isFinal_;

				public const int ControlInputFieldNumber = 8;

				private static readonly FieldCodec<int> _repeated_controlInput_codec = FieldCodec.ForInt32(66u);

				private readonly RepeatedField<int> controlInput_ = new RepeatedField<int>();

				public const int InaccurateFieldNumber = 17;

				private bool inaccurate_;

				[DebuggerNonUserCode]
				public static MessageParser<Node> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CostGraphDef.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string Device
				{
					get
					{
						return device_;
					}
					set
					{
						device_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public int Id
				{
					get
					{
						return id_;
					}
					set
					{
						id_ = value;
					}
				}

				[DebuggerNonUserCode]
				public RepeatedField<Types.InputInfo> InputInfo => inputInfo_;

				[DebuggerNonUserCode]
				public RepeatedField<Types.OutputInfo> OutputInfo => outputInfo_;

				[DebuggerNonUserCode]
				public long TemporaryMemorySize
				{
					get
					{
						return temporaryMemorySize_;
					}
					set
					{
						temporaryMemorySize_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long PersistentMemorySize
				{
					get
					{
						return persistentMemorySize_;
					}
					set
					{
						persistentMemorySize_ = value;
					}
				}

				[Obsolete]
				[DebuggerNonUserCode]
				public long HostTempMemorySize
				{
					get
					{
						return hostTempMemorySize_;
					}
					set
					{
						hostTempMemorySize_ = value;
					}
				}

				[Obsolete]
				[DebuggerNonUserCode]
				public long DeviceTempMemorySize
				{
					get
					{
						return deviceTempMemorySize_;
					}
					set
					{
						deviceTempMemorySize_ = value;
					}
				}

				[Obsolete]
				[DebuggerNonUserCode]
				public long DevicePersistentMemorySize
				{
					get
					{
						return devicePersistentMemorySize_;
					}
					set
					{
						devicePersistentMemorySize_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long ComputeCost
				{
					get
					{
						return computeCost_;
					}
					set
					{
						computeCost_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long ComputeTime
				{
					get
					{
						return computeTime_;
					}
					set
					{
						computeTime_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long MemoryTime
				{
					get
					{
						return memoryTime_;
					}
					set
					{
						memoryTime_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool IsFinal
				{
					get
					{
						return isFinal_;
					}
					set
					{
						isFinal_ = value;
					}
				}

				[DebuggerNonUserCode]
				public RepeatedField<int> ControlInput => controlInput_;

				[DebuggerNonUserCode]
				public bool Inaccurate
				{
					get
					{
						return inaccurate_;
					}
					set
					{
						inaccurate_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Node()
				{
				}

				[DebuggerNonUserCode]
				public Node(Node other)
					: this()
				{
					name_ = other.name_;
					device_ = other.device_;
					id_ = other.id_;
					inputInfo_ = other.inputInfo_.Clone();
					outputInfo_ = other.outputInfo_.Clone();
					temporaryMemorySize_ = other.temporaryMemorySize_;
					persistentMemorySize_ = other.persistentMemorySize_;
					hostTempMemorySize_ = other.hostTempMemorySize_;
					deviceTempMemorySize_ = other.deviceTempMemorySize_;
					devicePersistentMemorySize_ = other.devicePersistentMemorySize_;
					computeCost_ = other.computeCost_;
					computeTime_ = other.computeTime_;
					memoryTime_ = other.memoryTime_;
					isFinal_ = other.isFinal_;
					controlInput_ = other.controlInput_.Clone();
					inaccurate_ = other.inaccurate_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Node Clone()
				{
					return new Node(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Node);
				}

				[DebuggerNonUserCode]
				public bool Equals(Node other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (Device != other.Device)
					{
						return false;
					}
					if (Id != other.Id)
					{
						return false;
					}
					if (!inputInfo_.Equals(other.inputInfo_))
					{
						return false;
					}
					if (!outputInfo_.Equals(other.outputInfo_))
					{
						return false;
					}
					if (TemporaryMemorySize != other.TemporaryMemorySize)
					{
						return false;
					}
					if (PersistentMemorySize != other.PersistentMemorySize)
					{
						return false;
					}
					if (HostTempMemorySize != other.HostTempMemorySize)
					{
						return false;
					}
					if (DeviceTempMemorySize != other.DeviceTempMemorySize)
					{
						return false;
					}
					if (DevicePersistentMemorySize != other.DevicePersistentMemorySize)
					{
						return false;
					}
					if (ComputeCost != other.ComputeCost)
					{
						return false;
					}
					if (ComputeTime != other.ComputeTime)
					{
						return false;
					}
					if (MemoryTime != other.MemoryTime)
					{
						return false;
					}
					if (IsFinal != other.IsFinal)
					{
						return false;
					}
					if (!controlInput_.Equals(other.controlInput_))
					{
						return false;
					}
					if (Inaccurate != other.Inaccurate)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (Device.Length != 0)
					{
						num ^= Device.GetHashCode();
					}
					if (Id != 0)
					{
						num ^= Id.GetHashCode();
					}
					num ^= ((object)inputInfo_).GetHashCode();
					num ^= ((object)outputInfo_).GetHashCode();
					if (TemporaryMemorySize != 0L)
					{
						num ^= TemporaryMemorySize.GetHashCode();
					}
					if (PersistentMemorySize != 0L)
					{
						num ^= PersistentMemorySize.GetHashCode();
					}
					if (HostTempMemorySize != 0L)
					{
						num ^= HostTempMemorySize.GetHashCode();
					}
					if (DeviceTempMemorySize != 0L)
					{
						num ^= DeviceTempMemorySize.GetHashCode();
					}
					if (DevicePersistentMemorySize != 0L)
					{
						num ^= DevicePersistentMemorySize.GetHashCode();
					}
					if (ComputeCost != 0L)
					{
						num ^= ComputeCost.GetHashCode();
					}
					if (ComputeTime != 0L)
					{
						num ^= ComputeTime.GetHashCode();
					}
					if (MemoryTime != 0L)
					{
						num ^= MemoryTime.GetHashCode();
					}
					if (IsFinal)
					{
						num ^= IsFinal.GetHashCode();
					}
					num ^= ((object)controlInput_).GetHashCode();
					if (Inaccurate)
					{
						num ^= Inaccurate.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					if (Device.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(Device);
					}
					if (Id != 0)
					{
						output.WriteRawTag((byte)24);
						output.WriteInt32(Id);
					}
					inputInfo_.WriteTo(output, _repeated_inputInfo_codec);
					outputInfo_.WriteTo(output, _repeated_outputInfo_codec);
					if (TemporaryMemorySize != 0L)
					{
						output.WriteRawTag((byte)48);
						output.WriteInt64(TemporaryMemorySize);
					}
					if (IsFinal)
					{
						output.WriteRawTag((byte)56);
						output.WriteBool(IsFinal);
					}
					controlInput_.WriteTo(output, _repeated_controlInput_codec);
					if (ComputeCost != 0L)
					{
						output.WriteRawTag((byte)72);
						output.WriteInt64(ComputeCost);
					}
					if (HostTempMemorySize != 0L)
					{
						output.WriteRawTag((byte)80);
						output.WriteInt64(HostTempMemorySize);
					}
					if (DeviceTempMemorySize != 0L)
					{
						output.WriteRawTag((byte)88);
						output.WriteInt64(DeviceTempMemorySize);
					}
					if (PersistentMemorySize != 0L)
					{
						output.WriteRawTag((byte)96);
						output.WriteInt64(PersistentMemorySize);
					}
					if (ComputeTime != 0L)
					{
						output.WriteRawTag((byte)112);
						output.WriteInt64(ComputeTime);
					}
					if (MemoryTime != 0L)
					{
						output.WriteRawTag((byte)120);
						output.WriteInt64(MemoryTime);
					}
					if (DevicePersistentMemorySize != 0L)
					{
						output.WriteRawTag((byte)128, (byte)1);
						output.WriteInt64(DevicePersistentMemorySize);
					}
					if (Inaccurate)
					{
						output.WriteRawTag((byte)136, (byte)1);
						output.WriteBool(Inaccurate);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (Device.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Device);
					}
					if (Id != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Id);
					}
					num += inputInfo_.CalculateSize(_repeated_inputInfo_codec);
					num += outputInfo_.CalculateSize(_repeated_outputInfo_codec);
					if (TemporaryMemorySize != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(TemporaryMemorySize);
					}
					if (PersistentMemorySize != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(PersistentMemorySize);
					}
					if (HostTempMemorySize != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(HostTempMemorySize);
					}
					if (DeviceTempMemorySize != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(DeviceTempMemorySize);
					}
					if (DevicePersistentMemorySize != 0L)
					{
						num += 2 + CodedOutputStream.ComputeInt64Size(DevicePersistentMemorySize);
					}
					if (ComputeCost != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(ComputeCost);
					}
					if (ComputeTime != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(ComputeTime);
					}
					if (MemoryTime != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(MemoryTime);
					}
					if (IsFinal)
					{
						num += 2;
					}
					num += controlInput_.CalculateSize(_repeated_controlInput_codec);
					if (Inaccurate)
					{
						num += 3;
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Node other)
				{
					if (other != null)
					{
						if (other.Name.Length != 0)
						{
							Name = other.Name;
						}
						if (other.Device.Length != 0)
						{
							Device = other.Device;
						}
						if (other.Id != 0)
						{
							Id = other.Id;
						}
						inputInfo_.Add((IEnumerable<Types.InputInfo>)other.inputInfo_);
						outputInfo_.Add((IEnumerable<Types.OutputInfo>)other.outputInfo_);
						if (other.TemporaryMemorySize != 0L)
						{
							TemporaryMemorySize = other.TemporaryMemorySize;
						}
						if (other.PersistentMemorySize != 0L)
						{
							PersistentMemorySize = other.PersistentMemorySize;
						}
						if (other.HostTempMemorySize != 0L)
						{
							HostTempMemorySize = other.HostTempMemorySize;
						}
						if (other.DeviceTempMemorySize != 0L)
						{
							DeviceTempMemorySize = other.DeviceTempMemorySize;
						}
						if (other.DevicePersistentMemorySize != 0L)
						{
							DevicePersistentMemorySize = other.DevicePersistentMemorySize;
						}
						if (other.ComputeCost != 0L)
						{
							ComputeCost = other.ComputeCost;
						}
						if (other.ComputeTime != 0L)
						{
							ComputeTime = other.ComputeTime;
						}
						if (other.MemoryTime != 0L)
						{
							MemoryTime = other.MemoryTime;
						}
						if (other.IsFinal)
						{
							IsFinal = other.IsFinal;
						}
						controlInput_.Add((IEnumerable<int>)other.controlInput_);
						if (other.Inaccurate)
						{
							Inaccurate = other.Inaccurate;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 18u:
							Device = input.ReadString();
							break;
						case 24u:
							Id = input.ReadInt32();
							break;
						case 34u:
							inputInfo_.AddEntriesFrom(input, _repeated_inputInfo_codec);
							break;
						case 42u:
							outputInfo_.AddEntriesFrom(input, _repeated_outputInfo_codec);
							break;
						case 48u:
							TemporaryMemorySize = input.ReadInt64();
							break;
						case 56u:
							IsFinal = input.ReadBool();
							break;
						case 64u:
						case 66u:
							controlInput_.AddEntriesFrom(input, _repeated_controlInput_codec);
							break;
						case 72u:
							ComputeCost = input.ReadInt64();
							break;
						case 80u:
							HostTempMemorySize = input.ReadInt64();
							break;
						case 88u:
							DeviceTempMemorySize = input.ReadInt64();
							break;
						case 96u:
							PersistentMemorySize = input.ReadInt64();
							break;
						case 112u:
							ComputeTime = input.ReadInt64();
							break;
						case 120u:
							MemoryTime = input.ReadInt64();
							break;
						case 128u:
							DevicePersistentMemorySize = input.ReadInt64();
							break;
						case 136u:
							Inaccurate = input.ReadBool();
							break;
						}
					}
				}
			}

			public sealed class AggregatedCost : IMessage<AggregatedCost>, IMessage, IEquatable<AggregatedCost>, IDeepCloneable<AggregatedCost>
			{
				private static readonly MessageParser<AggregatedCost> _parser = new MessageParser<AggregatedCost>((Func<AggregatedCost>)(() => new AggregatedCost()));

				private UnknownFieldSet _unknownFields;

				public const int CostFieldNumber = 1;

				private float cost_;

				public const int DimensionFieldNumber = 2;

				private string dimension_ = "";

				[DebuggerNonUserCode]
				public static MessageParser<AggregatedCost> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CostGraphDef.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public float Cost
				{
					get
					{
						return cost_;
					}
					set
					{
						cost_ = value;
					}
				}

				[DebuggerNonUserCode]
				public string Dimension
				{
					get
					{
						return dimension_;
					}
					set
					{
						dimension_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public AggregatedCost()
				{
				}

				[DebuggerNonUserCode]
				public AggregatedCost(AggregatedCost other)
					: this()
				{
					cost_ = other.cost_;
					dimension_ = other.dimension_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public AggregatedCost Clone()
				{
					return new AggregatedCost(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as AggregatedCost);
				}

				[DebuggerNonUserCode]
				public bool Equals(AggregatedCost other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(Cost, other.Cost))
					{
						return false;
					}
					if (Dimension != other.Dimension)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Cost != 0f)
					{
						num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(Cost);
					}
					if (Dimension.Length != 0)
					{
						num ^= Dimension.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Cost != 0f)
					{
						output.WriteRawTag((byte)13);
						output.WriteFloat(Cost);
					}
					if (Dimension.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(Dimension);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Cost != 0f)
					{
						num += 5;
					}
					if (Dimension.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Dimension);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(AggregatedCost other)
				{
					if (other != null)
					{
						if (other.Cost != 0f)
						{
							Cost = other.Cost;
						}
						if (other.Dimension.Length != 0)
						{
							Dimension = other.Dimension;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 13u:
							Cost = input.ReadFloat();
							break;
						case 18u:
							Dimension = input.ReadString();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<CostGraphDef> _parser = new MessageParser<CostGraphDef>((Func<CostGraphDef>)(() => new CostGraphDef()));

		private UnknownFieldSet _unknownFields;

		public const int NodeFieldNumber = 1;

		private static readonly FieldCodec<Types.Node> _repeated_node_codec = FieldCodec.ForMessage<Types.Node>(10u, Types.Node.Parser);

		private readonly RepeatedField<Types.Node> node_ = new RepeatedField<Types.Node>();

		public const int CostFieldNumber = 2;

		private static readonly FieldCodec<Types.AggregatedCost> _repeated_cost_codec = FieldCodec.ForMessage<Types.AggregatedCost>(18u, Types.AggregatedCost.Parser);

		private readonly RepeatedField<Types.AggregatedCost> cost_ = new RepeatedField<Types.AggregatedCost>();

		[DebuggerNonUserCode]
		public static MessageParser<CostGraphDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => CostGraphReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Node> Node => node_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.AggregatedCost> Cost => cost_;

		[DebuggerNonUserCode]
		public CostGraphDef()
		{
		}

		[DebuggerNonUserCode]
		public CostGraphDef(CostGraphDef other)
			: this()
		{
			node_ = other.node_.Clone();
			cost_ = other.cost_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CostGraphDef Clone()
		{
			return new CostGraphDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CostGraphDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(CostGraphDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!node_.Equals(other.node_))
			{
				return false;
			}
			if (!cost_.Equals(other.cost_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)node_).GetHashCode();
			num ^= ((object)cost_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			node_.WriteTo(output, _repeated_node_codec);
			cost_.WriteTo(output, _repeated_cost_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += node_.CalculateSize(_repeated_node_codec);
			num += cost_.CalculateSize(_repeated_cost_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CostGraphDef other)
		{
			if (other != null)
			{
				node_.Add((IEnumerable<Types.Node>)other.node_);
				cost_.Add((IEnumerable<Types.AggregatedCost>)other.cost_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					node_.AddEntriesFrom(input, _repeated_node_codec);
					break;
				case 18u:
					cost_.AddEntriesFrom(input, _repeated_cost_codec);
					break;
				}
			}
		}
	}
	public static class CppShapeInferenceReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static CppShapeInferenceReflection()
		{
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Expected O, but got Unknown
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Expected O, but got Unknown
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Expected O, but got Unknown
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected O, but got Unknown
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CjJ0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vY3BwX3NoYXBlX2luZmVyZW5j" + "ZS5wcm90bxILdGVuc29yYm9hcmQaKHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90" + "by9mdWxsX3R5cGUucHJvdG8aK3RlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90" + "ZW5zb3Jfc2hhcGUucHJvdG8aJHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90" + "eXBlcy5wcm90byKhAwoXQ3BwU2hhcGVJbmZlcmVuY2VSZXN1bHQSLAoFc2hh" + "cGUYASABKAsyHS50ZW5zb3Jib2FyZC5UZW5zb3JTaGFwZVByb3RvEkQKC2hh" + "bmRsZV9kYXRhGAQgASgLMi8udGVuc29yYm9hcmQuQ3BwU2hhcGVJbmZlcmVu" + "Y2VSZXN1bHQuSGFuZGxlRGF0YRqWAQoSSGFuZGxlU2hhcGVBbmRUeXBlEiwK" + "BXNoYXBlGAEgASgLMh0udGVuc29yYm9hcmQuVGVuc29yU2hhcGVQcm90bxIk" + "CgVkdHlwZRgCIAEoDjIVLnRlbnNvcmJvYXJkLkRhdGFUeXBlEiYKBHR5cGUY" + "BCABKAsyGC50ZW5zb3Jib2FyZC5GdWxsVHlwZURlZkoECAMQBBptCgpIYW5k" + "bGVEYXRhEg4KBmlzX3NldBgBIAEoCBJPCg5zaGFwZV9hbmRfdHlwZRgCIAMo" + "CzI3LnRlbnNvcmJvYXJkLkNwcFNoYXBlSW5mZXJlbmNlUmVzdWx0LkhhbmRs" + "ZVNoYXBlQW5kVHlwZUoECAIQA0oECAMQBCJlCh1DcHBTaGFwZUluZmVyZW5j" + "ZUlucHV0c05lZWRlZBIcChRpbnB1dF90ZW5zb3JzX25lZWRlZBgBIAMoBRIm" + "Ch5pbnB1dF90ZW5zb3JzX2FzX3NoYXBlc19uZWVkZWQYAiADKAVCYVpcZ2l0" + "aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9nby9w" + "eXRob24vZnJhbWV3b3JrL2NwcF9zaGFwZV9pbmZlcmVuY2VfZ29fcHJvdG/4" + "AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				FullTypeReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(CppShapeInferenceResult), (MessageParser)(object)CppShapeInferenceResult.Parser, new string[2] { "Shape", "HandleData" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
				{
					new GeneratedClrTypeInfo(typeof(CppShapeInferenceResult.Types.HandleShapeAndType), (MessageParser)(object)CppShapeInferenceResult.Types.HandleShapeAndType.Parser, new string[3] { "Shape", "Dtype", "Type" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(CppShapeInferenceResult.Types.HandleData), (MessageParser)(object)CppShapeInferenceResult.Types.HandleData.Parser, new string[2] { "IsSet", "ShapeAndType" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(CppShapeInferenceInputsNeeded), (MessageParser)(object)CppShapeInferenceInputsNeeded.Parser, new string[2] { "InputTensorsNeeded", "InputTensorsAsShapesNeeded" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class CppShapeInferenceResult : IMessage<CppShapeInferenceResult>, IMessage, IEquatable<CppShapeInferenceResult>, IDeepCloneable<CppShapeInferenceResult>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class HandleShapeAndType : IMessage<HandleShapeAndType>, IMessage, IEquatable<HandleShapeAndType>, IDeepCloneable<HandleShapeAndType>
			{
				private static readonly MessageParser<HandleShapeAndType> _parser = new MessageParser<HandleShapeAndType>((Func<HandleShapeAndType>)(() => new HandleShapeAndType()));

				private UnknownFieldSet _unknownFields;

				public const int ShapeFieldNumber = 1;

				private TensorShapeProto shape_;

				public const int DtypeFieldNumber = 2;

				private DataType dtype_;

				public const int TypeFieldNumber = 4;

				private FullTypeDef type_;

				[DebuggerNonUserCode]
				public static MessageParser<HandleShapeAndType> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CppShapeInferenceResult.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public TensorShapeProto Shape
				{
					get
					{
						return shape_;
					}
					set
					{
						shape_ = value;
					}
				}

				[DebuggerNonUserCode]
				public DataType Dtype
				{
					get
					{
						return dtype_;
					}
					set
					{
						dtype_ = value;
					}
				}

				[DebuggerNonUserCode]
				public FullTypeDef Type
				{
					get
					{
						return type_;
					}
					set
					{
						type_ = value;
					}
				}

				[DebuggerNonUserCode]
				public HandleShapeAndType()
				{
				}

				[DebuggerNonUserCode]
				public HandleShapeAndType(HandleShapeAndType other)
					: this()
				{
					shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
					dtype_ = other.dtype_;
					type_ = ((other.type_ != null) ? other.type_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public HandleShapeAndType Clone()
				{
					return new HandleShapeAndType(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as HandleShapeAndType);
				}

				[DebuggerNonUserCode]
				public bool Equals(HandleShapeAndType other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!object.Equals(Shape, other.Shape))
					{
						return false;
					}
					if (Dtype != other.Dtype)
					{
						return false;
					}
					if (!object.Equals(Type, other.Type))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (shape_ != null)
					{
						num ^= Shape.GetHashCode();
					}
					if (Dtype != DataType.DtInvalid)
					{
						num ^= Dtype.GetHashCode();
					}
					if (type_ != null)
					{
						num ^= Type.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (shape_ != null)
					{
						output.WriteRawTag((byte)10);
						output.WriteMessage((IMessage)(object)Shape);
					}
					if (Dtype != DataType.DtInvalid)
					{
						output.WriteRawTag((byte)16);
						output.WriteEnum((int)Dtype);
					}
					if (type_ != null)
					{
						output.WriteRawTag((byte)34);
						output.WriteMessage((IMessage)(object)Type);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (shape_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
					}
					if (Dtype != DataType.DtInvalid)
					{
						num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
					}
					if (type_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Type);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(HandleShapeAndType other)
				{
					if (other == null)
					{
						return;
					}
					if (other.shape_ != null)
					{
						if (shape_ == null)
						{
							Shape = new TensorShapeProto();
						}
						Shape.MergeFrom(other.Shape);
					}
					if (other.Dtype != DataType.DtInvalid)
					{
						Dtype = other.Dtype;
					}
					if (other.type_ != null)
					{
						if (type_ == null)
						{
							Type = new FullTypeDef();
						}
						Type.MergeFrom(other.Type);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							if (shape_ == null)
							{
								Shape = new TensorShapeProto();
							}
							input.ReadMessage((IMessage)(object)Shape);
							break;
						case 16u:
							Dtype = (DataType)input.ReadEnum();
							break;
						case 34u:
							if (type_ == null)
							{
								Type = new FullTypeDef();
							}
							input.ReadMessage((IMessage)(object)Type);
							break;
						}
					}
				}
			}

			public sealed class HandleData : IMessage<HandleData>, IMessage, IEquatable<HandleData>, IDeepCloneable<HandleData>
			{
				private static readonly MessageParser<HandleData> _parser = new MessageParser<HandleData>((Func<HandleData>)(() => new HandleData()));

				private UnknownFieldSet _unknownFields;

				public const int IsSetFieldNumber = 1;

				private bool isSet_;

				public const int ShapeAndTypeFieldNumber = 2;

				private static readonly FieldCodec<HandleShapeAndType> _repeated_shapeAndType_codec = FieldCodec.ForMessage<HandleShapeAndType>(18u, HandleShapeAndType.Parser);

				private readonly RepeatedField<HandleShapeAndType> shapeAndType_ = new RepeatedField<HandleShapeAndType>();

				[DebuggerNonUserCode]
				public static MessageParser<HandleData> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CppShapeInferenceResult.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public bool IsSet
				{
					get
					{
						return isSet_;
					}
					set
					{
						isSet_ = value;
					}
				}

				[DebuggerNonUserCode]
				public RepeatedField<HandleShapeAndType> ShapeAndType => shapeAndType_;

				[DebuggerNonUserCode]
				public HandleData()
				{
				}

				[DebuggerNonUserCode]
				public HandleData(HandleData other)
					: this()
				{
					isSet_ = other.isSet_;
					shapeAndType_ = other.shapeAndType_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public HandleData Clone()
				{
					return new HandleData(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as HandleData);
				}

				[DebuggerNonUserCode]
				public bool Equals(HandleData other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (IsSet != other.IsSet)
					{
						return false;
					}
					if (!shapeAndType_.Equals(other.shapeAndType_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (IsSet)
					{
						num ^= IsSet.GetHashCode();
					}
					num ^= ((object)shapeAndType_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (IsSet)
					{
						output.WriteRawTag((byte)8);
						output.WriteBool(IsSet);
					}
					shapeAndType_.WriteTo(output, _repeated_shapeAndType_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (IsSet)
					{
						num += 2;
					}
					num += shapeAndType_.CalculateSize(_repeated_shapeAndType_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(HandleData other)
				{
					if (other != null)
					{
						if (other.IsSet)
						{
							IsSet = other.IsSet;
						}
						shapeAndType_.Add((IEnumerable<HandleShapeAndType>)other.shapeAndType_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 8u:
							IsSet = input.ReadBool();
							break;
						case 18u:
							shapeAndType_.AddEntriesFrom(input, _repeated_shapeAndType_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<CppShapeInferenceResult> _parser = new MessageParser<CppShapeInferenceResult>((Func<CppShapeInferenceResult>)(() => new CppShapeInferenceResult()));

		private UnknownFieldSet _unknownFields;

		public const int ShapeFieldNumber = 1;

		private TensorShapeProto shape_;

		public const int HandleDataFieldNumber = 4;

		private Types.HandleData handleData_;

		[DebuggerNonUserCode]
		public static MessageParser<CppShapeInferenceResult> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => CppShapeInferenceReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public TensorShapeProto Shape
		{
			get
			{
				return shape_;
			}
			set
			{
				shape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.HandleData HandleData
		{
			get
			{
				return handleData_;
			}
			set
			{
				handleData_ = value;
			}
		}

		[DebuggerNonUserCode]
		public CppShapeInferenceResult()
		{
		}

		[DebuggerNonUserCode]
		public CppShapeInferenceResult(CppShapeInferenceResult other)
			: this()
		{
			shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
			handleData_ = ((other.handleData_ != null) ? other.handleData_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CppShapeInferenceResult Clone()
		{
			return new CppShapeInferenceResult(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CppShapeInferenceResult);
		}

		[DebuggerNonUserCode]
		public bool Equals(CppShapeInferenceResult other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(Shape, other.Shape))
			{
				return false;
			}
			if (!object.Equals(HandleData, other.HandleData))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (shape_ != null)
			{
				num ^= Shape.GetHashCode();
			}
			if (handleData_ != null)
			{
				num ^= HandleData.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (shape_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)Shape);
			}
			if (handleData_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)HandleData);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (shape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
			}
			if (handleData_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)HandleData);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CppShapeInferenceResult other)
		{
			if (other == null)
			{
				return;
			}
			if (other.shape_ != null)
			{
				if (shape_ == null)
				{
					Shape = new TensorShapeProto();
				}
				Shape.MergeFrom(other.Shape);
			}
			if (other.handleData_ != null)
			{
				if (handleData_ == null)
				{
					HandleData = new Types.HandleData();
				}
				HandleData.MergeFrom(other.HandleData);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (shape_ == null)
					{
						Shape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)Shape);
					break;
				case 34u:
					if (handleData_ == null)
					{
						HandleData = new Types.HandleData();
					}
					input.ReadMessage((IMessage)(object)HandleData);
					break;
				}
			}
		}
	}
	public sealed class CppShapeInferenceInputsNeeded : IMessage<CppShapeInferenceInputsNeeded>, IMessage, IEquatable<CppShapeInferenceInputsNeeded>, IDeepCloneable<CppShapeInferenceInputsNeeded>
	{
		private static readonly MessageParser<CppShapeInferenceInputsNeeded> _parser = new MessageParser<CppShapeInferenceInputsNeeded>((Func<CppShapeInferenceInputsNeeded>)(() => new CppShapeInferenceInputsNeeded()));

		private UnknownFieldSet _unknownFields;

		public const int InputTensorsNeededFieldNumber = 1;

		private static readonly FieldCodec<int> _repeated_inputTensorsNeeded_codec = FieldCodec.ForInt32(10u);

		private readonly RepeatedField<int> inputTensorsNeeded_ = new RepeatedField<int>();

		public const int InputTensorsAsShapesNeededFieldNumber = 2;

		private static readonly FieldCodec<int> _repeated_inputTensorsAsShapesNeeded_codec = FieldCodec.ForInt32(18u);

		private readonly RepeatedField<int> inputTensorsAsShapesNeeded_ = new RepeatedField<int>();

		[DebuggerNonUserCode]
		public static MessageParser<CppShapeInferenceInputsNeeded> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => CppShapeInferenceReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<int> InputTensorsNeeded => inputTensorsNeeded_;

		[DebuggerNonUserCode]
		public RepeatedField<int> InputTensorsAsShapesNeeded => inputTensorsAsShapesNeeded_;

		[DebuggerNonUserCode]
		public CppShapeInferenceInputsNeeded()
		{
		}

		[DebuggerNonUserCode]
		public CppShapeInferenceInputsNeeded(CppShapeInferenceInputsNeeded other)
			: this()
		{
			inputTensorsNeeded_ = other.inputTensorsNeeded_.Clone();
			inputTensorsAsShapesNeeded_ = other.inputTensorsAsShapesNeeded_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CppShapeInferenceInputsNeeded Clone()
		{
			return new CppShapeInferenceInputsNeeded(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CppShapeInferenceInputsNeeded);
		}

		[DebuggerNonUserCode]
		public bool Equals(CppShapeInferenceInputsNeeded other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!inputTensorsNeeded_.Equals(other.inputTensorsNeeded_))
			{
				return false;
			}
			if (!inputTensorsAsShapesNeeded_.Equals(other.inputTensorsAsShapesNeeded_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)inputTensorsNeeded_).GetHashCode();
			num ^= ((object)inputTensorsAsShapesNeeded_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			inputTensorsNeeded_.WriteTo(output, _repeated_inputTensorsNeeded_codec);
			inputTensorsAsShapesNeeded_.WriteTo(output, _repeated_inputTensorsAsShapesNeeded_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += inputTensorsNeeded_.CalculateSize(_repeated_inputTensorsNeeded_codec);
			num += inputTensorsAsShapesNeeded_.CalculateSize(_repeated_inputTensorsAsShapesNeeded_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CppShapeInferenceInputsNeeded other)
		{
			if (other != null)
			{
				inputTensorsNeeded_.Add((IEnumerable<int>)other.inputTensorsNeeded_);
				inputTensorsAsShapesNeeded_.Add((IEnumerable<int>)other.inputTensorsAsShapesNeeded_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
				case 10u:
					inputTensorsNeeded_.AddEntriesFrom(input, _repeated_inputTensorsNeeded_codec);
					break;
				case 16u:
				case 18u:
					inputTensorsAsShapesNeeded_.AddEntriesFrom(input, _repeated_inputTensorsAsShapesNeeded_codec);
					break;
				}
			}
		}
	}
	public static class DebugReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static DebugReflection()
		{
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiR0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vZGVidWcucHJvdG8SC3RlbnNv" + "cmJvYXJkIo4BChBEZWJ1Z1RlbnNvcldhdGNoEhEKCW5vZGVfbmFtZRgBIAEo" + "CRITCgtvdXRwdXRfc2xvdBgCIAEoBRIRCglkZWJ1Z19vcHMYAyADKAkSEgoK" + "ZGVidWdfdXJscxgEIAMoCRIrCiN0b2xlcmF0ZV9kZWJ1Z19vcF9jcmVhdGlv" + "bl9mYWlsdXJlcxgFIAEoCCKCAQoMRGVidWdPcHRpb25zEj4KF2RlYnVnX3Rl" + "bnNvcl93YXRjaF9vcHRzGAQgAygLMh0udGVuc29yYm9hcmQuRGVidWdUZW5z" + "b3JXYXRjaBITCgtnbG9iYWxfc3RlcBgKIAEoAxIdChVyZXNldF9kaXNrX2J5" + "dGVfdXNhZ2UYCyABKAgiagoSRGVidWdnZWRTb3VyY2VGaWxlEgwKBGhvc3QY" + "ASABKAkSEQoJZmlsZV9wYXRoGAIgASgJEhUKDWxhc3RfbW9kaWZpZWQYAyAB" + "KAMSDQoFYnl0ZXMYBCABKAMSDQoFbGluZXMYBSADKAkiTAoTRGVidWdnZWRT" + "b3VyY2VGaWxlcxI1Cgxzb3VyY2VfZmlsZXMYASADKAsyHy50ZW5zb3Jib2Fy" + "ZC5EZWJ1Z2dlZFNvdXJjZUZpbGVCgwEKGG9yZy50ZW5zb3JmbG93LmZyYW1l" + "d29ya0ILRGVidWdQcm90b3NQAVpVZ2l0aHViLmNvbS90ZW5zb3JmbG93L3Rl" + "bnNvcmZsb3cvdGVuc29yZmxvdy9nby9jb3JlL3Byb3RvYnVmL2Zvcl9jb3Jl" + "X3Byb3Rvc19nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[4]
			{
				new GeneratedClrTypeInfo(typeof(DebugTensorWatch), (MessageParser)(object)DebugTensorWatch.Parser, new string[5] { "NodeName", "OutputSlot", "DebugOps", "DebugUrls", "TolerateDebugOpCreationFailures" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(DebugOptions), (MessageParser)(object)DebugOptions.Parser, new string[3] { "DebugTensorWatchOpts", "GlobalStep", "ResetDiskByteUsage" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(DebuggedSourceFile), (MessageParser)(object)DebuggedSourceFile.Parser, new string[5] { "Host", "FilePath", "LastModified", "Bytes", "Lines" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(DebuggedSourceFiles), (MessageParser)(object)DebuggedSourceFiles.Parser, new string[1] { "SourceFiles" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class DebugTensorWatch : IMessage<DebugTensorWatch>, IMessage, IEquatable<DebugTensorWatch>, IDeepCloneable<DebugTensorWatch>
	{
		private static readonly MessageParser<DebugTensorWatch> _parser = new MessageParser<DebugTensorWatch>((Func<DebugTensorWatch>)(() => new DebugTensorWatch()));

		private UnknownFieldSet _unknownFields;

		public const int NodeNameFieldNumber = 1;

		private string nodeName_ = "";

		public const int OutputSlotFieldNumber = 2;

		private int outputSlot_;

		public const int DebugOpsFieldNumber = 3;

		private static readonly FieldCodec<string> _repeated_debugOps_codec = FieldCodec.ForString(26u);

		private readonly RepeatedField<string> debugOps_ = new RepeatedField<string>();

		public const int DebugUrlsFieldNumber = 4;

		private static readonly FieldCodec<string> _repeated_debugUrls_codec = FieldCodec.ForString(34u);

		private readonly RepeatedField<string> debugUrls_ = new RepeatedField<string>();

		public const int TolerateDebugOpCreationFailuresFieldNumber = 5;

		private bool tolerateDebugOpCreationFailures_;

		[DebuggerNonUserCode]
		public static MessageParser<DebugTensorWatch> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => DebugReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string NodeName
		{
			get
			{
				return nodeName_;
			}
			set
			{
				nodeName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public int OutputSlot
		{
			get
			{
				return outputSlot_;
			}
			set
			{
				outputSlot_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> DebugOps => debugOps_;

		[DebuggerNonUserCode]
		public RepeatedField<string> DebugUrls => debugUrls_;

		[DebuggerNonUserCode]
		public bool TolerateDebugOpCreationFailures
		{
			get
			{
				return tolerateDebugOpCreationFailures_;
			}
			set
			{
				tolerateDebugOpCreationFailures_ = value;
			}
		}

		[DebuggerNonUserCode]
		public DebugTensorWatch()
		{
		}

		[DebuggerNonUserCode]
		public DebugTensorWatch(DebugTensorWatch other)
			: this()
		{
			nodeName_ = other.nodeName_;
			outputSlot_ = other.outputSlot_;
			debugOps_ = other.debugOps_.Clone();
			debugUrls_ = other.debugUrls_.Clone();
			tolerateDebugOpCreationFailures_ = other.tolerateDebugOpCreationFailures_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public DebugTensorWatch Clone()
		{
			return new DebugTensorWatch(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as DebugTensorWatch);
		}

		[DebuggerNonUserCode]
		public bool Equals(DebugTensorWatch other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (NodeName != other.NodeName)
			{
				return false;
			}
			if (OutputSlot != other.OutputSlot)
			{
				return false;
			}
			if (!debugOps_.Equals(other.debugOps_))
			{
				return false;
			}
			if (!debugUrls_.Equals(other.debugUrls_))
			{
				return false;
			}
			if (TolerateDebugOpCreationFailures != other.TolerateDebugOpCreationFailures)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (NodeName.Length != 0)
			{
				num ^= NodeName.GetHashCode();
			}
			if (OutputSlot != 0)
			{
				num ^= OutputSlot.GetHashCode();
			}
			num ^= ((object)debugOps_).GetHashCode();
			num ^= ((object)debugUrls_).GetHashCode();
			if (TolerateDebugOpCreationFailures)
			{
				num ^= TolerateDebugOpCreationFailures.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (NodeName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(NodeName);
			}
			if (OutputSlot != 0)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt32(OutputSlot);
			}
			debugOps_.WriteTo(output, _repeated_debugOps_codec);
			debugUrls_.WriteTo(output, _repeated_debugUrls_codec);
			if (TolerateDebugOpCreationFailures)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(TolerateDebugOpCreationFailures);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (NodeName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(NodeName);
			}
			if (OutputSlot != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(OutputSlot);
			}
			num += debugOps_.CalculateSize(_repeated_debugOps_codec);
			num += debugUrls_.CalculateSize(_repeated_debugUrls_codec);
			if (TolerateDebugOpCreationFailures)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(DebugTensorWatch other)
		{
			if (other != null)
			{
				if (other.NodeName.Length != 0)
				{
					NodeName = other.NodeName;
				}
				if (other.OutputSlot != 0)
				{
					OutputSlot = other.OutputSlot;
				}
				debugOps_.Add((IEnumerable<string>)other.debugOps_);
				debugUrls_.Add((IEnumerable<string>)other.debugUrls_);
				if (other.TolerateDebugOpCreationFailures)
				{
					TolerateDebugOpCreationFailures = other.TolerateDebugOpCreationFailures;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					NodeName = input.ReadString();
					break;
				case 16u:
					OutputSlot = input.ReadInt32();
					break;
				case 26u:
					debugOps_.AddEntriesFrom(input, _repeated_debugOps_codec);
					break;
				case 34u:
					debugUrls_.AddEntriesFrom(input, _repeated_debugUrls_codec);
					break;
				case 40u:
					TolerateDebugOpCreationFailures = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class DebugOptions : IMessage<DebugOptions>, IMessage, IEquatable<DebugOptions>, IDeepCloneable<DebugOptions>
	{
		private static readonly MessageParser<DebugOptions> _parser = new MessageParser<DebugOptions>((Func<DebugOptions>)(() => new DebugOptions()));

		private UnknownFieldSet _unknownFields;

		public const int DebugTensorWatchOptsFieldNumber = 4;

		private static readonly FieldCodec<DebugTensorWatch> _repeated_debugTensorWatchOpts_codec = FieldCodec.ForMessage<DebugTensorWatch>(34u, DebugTensorWatch.Parser);

		private readonly RepeatedField<DebugTensorWatch> debugTensorWatchOpts_ = new RepeatedField<DebugTensorWatch>();

		public const int GlobalStepFieldNumber = 10;

		private long globalStep_;

		public const int ResetDiskByteUsageFieldNumber = 11;

		private bool resetDiskByteUsage_;

		[DebuggerNonUserCode]
		public static MessageParser<DebugOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => DebugReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<DebugTensorWatch> DebugTensorWatchOpts => debugTensorWatchOpts_;

		[DebuggerNonUserCode]
		public long GlobalStep
		{
			get
			{
				return globalStep_;
			}
			set
			{
				globalStep_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool ResetDiskByteUsage
		{
			get
			{
				return resetDiskByteUsage_;
			}
			set
			{
				resetDiskByteUsage_ = value;
			}
		}

		[DebuggerNonUserCode]
		public DebugOptions()
		{
		}

		[DebuggerNonUserCode]
		public DebugOptions(DebugOptions other)
			: this()
		{
			debugTensorWatchOpts_ = other.debugTensorWatchOpts_.Clone();
			globalStep_ = other.globalStep_;
			resetDiskByteUsage_ = other.resetDiskByteUsage_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public DebugOptions Clone()
		{
			return new DebugOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as DebugOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(DebugOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!debugTensorWatchOpts_.Equals(other.debugTensorWatchOpts_))
			{
				return false;
			}
			if (GlobalStep != other.GlobalStep)
			{
				return false;
			}
			if (ResetDiskByteUsage != other.ResetDiskByteUsage)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)debugTensorWatchOpts_).GetHashCode();
			if (GlobalStep != 0L)
			{
				num ^= GlobalStep.GetHashCode();
			}
			if (ResetDiskByteUsage)
			{
				num ^= ResetDiskByteUsage.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			debugTensorWatchOpts_.WriteTo(output, _repeated_debugTensorWatchOpts_codec);
			if (GlobalStep != 0L)
			{
				output.WriteRawTag((byte)80);
				output.WriteInt64(GlobalStep);
			}
			if (ResetDiskByteUsage)
			{
				output.WriteRawTag((byte)88);
				output.WriteBool(ResetDiskByteUsage);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += debugTensorWatchOpts_.CalculateSize(_repeated_debugTensorWatchOpts_codec);
			if (GlobalStep != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(GlobalStep);
			}
			if (ResetDiskByteUsage)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(DebugOptions other)
		{
			if (other != null)
			{
				debugTensorWatchOpts_.Add((IEnumerable<DebugTensorWatch>)other.debugTensorWatchOpts_);
				if (other.GlobalStep != 0L)
				{
					GlobalStep = other.GlobalStep;
				}
				if (other.ResetDiskByteUsage)
				{
					ResetDiskByteUsage = other.ResetDiskByteUsage;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 34u:
					debugTensorWatchOpts_.AddEntriesFrom(input, _repeated_debugTensorWatchOpts_codec);
					break;
				case 80u:
					GlobalStep = input.ReadInt64();
					break;
				case 88u:
					ResetDiskByteUsage = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class DebuggedSourceFile : IMessage<DebuggedSourceFile>, IMessage, IEquatable<DebuggedSourceFile>, IDeepCloneable<DebuggedSourceFile>
	{
		private static readonly MessageParser<DebuggedSourceFile> _parser = new MessageParser<DebuggedSourceFile>((Func<DebuggedSourceFile>)(() => new DebuggedSourceFile()));

		private UnknownFieldSet _unknownFields;

		public const int HostFieldNumber = 1;

		private string host_ = "";

		public const int FilePathFieldNumber = 2;

		private string filePath_ = "";

		public const int LastModifiedFieldNumber = 3;

		private long lastModified_;

		public const int BytesFieldNumber = 4;

		private long bytes_;

		public const int LinesFieldNumber = 5;

		private static readonly FieldCodec<string> _repeated_lines_codec = FieldCodec.ForString(42u);

		private readonly RepeatedField<string> lines_ = new RepeatedField<string>();

		[DebuggerNonUserCode]
		public static MessageParser<DebuggedSourceFile> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => DebugReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Host
		{
			get
			{
				return host_;
			}
			set
			{
				host_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string FilePath
		{
			get
			{
				return filePath_;
			}
			set
			{
				filePath_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long LastModified
		{
			get
			{
				return lastModified_;
			}
			set
			{
				lastModified_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long Bytes
		{
			get
			{
				return bytes_;
			}
			set
			{
				bytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> Lines => lines_;

		[DebuggerNonUserCode]
		public DebuggedSourceFile()
		{
		}

		[DebuggerNonUserCode]
		public DebuggedSourceFile(DebuggedSourceFile other)
			: this()
		{
			host_ = other.host_;
			filePath_ = other.filePath_;
			lastModified_ = other.lastModified_;
			bytes_ = other.bytes_;
			lines_ = other.lines_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public DebuggedSourceFile Clone()
		{
			return new DebuggedSourceFile(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as DebuggedSourceFile);
		}

		[DebuggerNonUserCode]
		public bool Equals(DebuggedSourceFile other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Host != other.Host)
			{
				return false;
			}
			if (FilePath != other.FilePath)
			{
				return false;
			}
			if (LastModified != other.LastModified)
			{
				return false;
			}
			if (Bytes != other.Bytes)
			{
				return false;
			}
			if (!lines_.Equals(other.lines_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Host.Length != 0)
			{
				num ^= Host.GetHashCode();
			}
			if (FilePath.Length != 0)
			{
				num ^= FilePath.GetHashCode();
			}
			if (LastModified != 0L)
			{
				num ^= LastModified.GetHashCode();
			}
			if (Bytes != 0L)
			{
				num ^= Bytes.GetHashCode();
			}
			num ^= ((object)lines_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Host.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Host);
			}
			if (FilePath.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(FilePath);
			}
			if (LastModified != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(LastModified);
			}
			if (Bytes != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(Bytes);
			}
			lines_.WriteTo(output, _repeated_lines_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Host.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Host);
			}
			if (FilePath.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FilePath);
			}
			if (LastModified != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(LastModified);
			}
			if (Bytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Bytes);
			}
			num += lines_.CalculateSize(_repeated_lines_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(DebuggedSourceFile other)
		{
			if (other != null)
			{
				if (other.Host.Length != 0)
				{
					Host = other.Host;
				}
				if (other.FilePath.Length != 0)
				{
					FilePath = other.FilePath;
				}
				if (other.LastModified != 0L)
				{
					LastModified = other.LastModified;
				}
				if (other.Bytes != 0L)
				{
					Bytes = other.Bytes;
				}
				lines_.Add((IEnumerable<string>)other.lines_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Host = input.ReadString();
					break;
				case 18u:
					FilePath = input.ReadString();
					break;
				case 24u:
					LastModified = input.ReadInt64();
					break;
				case 32u:
					Bytes = input.ReadInt64();
					break;
				case 42u:
					lines_.AddEntriesFrom(input, _repeated_lines_codec);
					break;
				}
			}
		}
	}
	public sealed class DebuggedSourceFiles : IMessage<DebuggedSourceFiles>, IMessage, IEquatable<DebuggedSourceFiles>, IDeepCloneable<DebuggedSourceFiles>
	{
		private static readonly MessageParser<DebuggedSourceFiles> _parser = new MessageParser<DebuggedSourceFiles>((Func<DebuggedSourceFiles>)(() => new DebuggedSourceFiles()));

		private UnknownFieldSet _unknownFields;

		public const int SourceFilesFieldNumber = 1;

		private static readonly FieldCodec<DebuggedSourceFile> _repeated_sourceFiles_codec = FieldCodec.ForMessage<DebuggedSourceFile>(10u, DebuggedSourceFile.Parser);

		private readonly RepeatedField<DebuggedSourceFile> sourceFiles_ = new RepeatedField<DebuggedSourceFile>();

		[DebuggerNonUserCode]
		public static MessageParser<DebuggedSourceFiles> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => DebugReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<DebuggedSourceFile> SourceFiles => sourceFiles_;

		[DebuggerNonUserCode]
		public DebuggedSourceFiles()
		{
		}

		[DebuggerNonUserCode]
		public DebuggedSourceFiles(DebuggedSourceFiles other)
			: this()
		{
			sourceFiles_ = other.sourceFiles_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public DebuggedSourceFiles Clone()
		{
			return new DebuggedSourceFiles(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as DebuggedSourceFiles);
		}

		[DebuggerNonUserCode]
		public bool Equals(DebuggedSourceFiles other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!sourceFiles_.Equals(other.sourceFiles_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)sourceFiles_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			sourceFiles_.WriteTo(output, _repeated_sourceFiles_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += sourceFiles_.CalculateSize(_repeated_sourceFiles_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(DebuggedSourceFiles other)
		{
			if (other != null)
			{
				sourceFiles_.Add((IEnumerable<DebuggedSourceFile>)other.sourceFiles_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					sourceFiles_.AddEntriesFrom(input, _repeated_sourceFiles_codec);
				}
			}
		}
	}
	public static class EventReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static EventReflection()
		{
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected O, but got Unknown
			//IL_022c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Expected O, but got Unknown
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Expected O, but got Unknown
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Expected O, but got Unknown
			//IL_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Expected O, but got Unknown
			//IL_036c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Expected O, but got Unknown
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_037c: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiR0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vZXZlbnQucHJvdG8SC3RlbnNv" + "cmJvYXJkGiZ0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc3VtbWFyeS5wcm90" + "byLDAgoFRXZlbnQSEQoJd2FsbF90aW1lGAEgASgBEgwKBHN0ZXAYAiABKAMS" + "FgoMZmlsZV92ZXJzaW9uGAMgASgJSAASEwoJZ3JhcGhfZGVmGAQgASgMSAAS" + "JwoHc3VtbWFyeRgFIAEoCzIULnRlbnNvcmJvYXJkLlN1bW1hcnlIABIyCgts" + "b2dfbWVzc2FnZRgGIAEoCzIXLnRlbnNvcmJvYXJkLkxvZ01lc3NhZ2VCAhgB" + "SAASLgoLc2Vzc2lvbl9sb2cYByABKAsyFy50ZW5zb3Jib2FyZC5TZXNzaW9u" + "TG9nSAASPQoTdGFnZ2VkX3J1bl9tZXRhZGF0YRgIIAEoCzIeLnRlbnNvcmJv" + "YXJkLlRhZ2dlZFJ1bk1ldGFkYXRhSAASGAoObWV0YV9ncmFwaF9kZWYYCSAB" + "KAxIAEIGCgR3aGF0IqIBCgpMb2dNZXNzYWdlEiwKBWxldmVsGAEgASgOMh0u" + "dGVuc29yYm9hcmQuTG9nTWVzc2FnZS5MZXZlbBIPCgdtZXNzYWdlGAIgASgJ" + "IlEKBUxldmVsEgsKB1VOS05PV04QABINCglERUJVR0dJTkcQChIICgRJTkZP" + "EBQSCAoEV0FSThAeEgkKBUVSUk9SECgSCQoFRkFUQUwQMhoCGAE6AhgBIrcB" + "CgpTZXNzaW9uTG9nEjUKBnN0YXR1cxgBIAEoDjIlLnRlbnNvcmJvYXJkLlNl" + "c3Npb25Mb2cuU2Vzc2lvblN0YXR1cxIXCg9jaGVja3BvaW50X3BhdGgYAiAB" + "KAkSCwoDbXNnGAMgASgJIkwKDVNlc3Npb25TdGF0dXMSFgoSU1RBVFVTX1VO" + "U1BFQ0lGSUVEEAASCQoFU1RBUlQQARIICgRTVE9QEAISDgoKQ0hFQ0tQT0lO" + "VBADIjYKEVRhZ2dlZFJ1bk1ldGFkYXRhEgsKA3RhZxgBIAEoCRIUCgxydW5f" + "bWV0YWRhdGEYAiABKAwiJAoOV2F0Y2hkb2dDb25maWcSEgoKdGltZW91dF9t" + "cxgBIAEoAyImChFSZXF1ZXN0ZWRFeGl0Q29kZRIRCglleGl0X2NvZGUYASAB" + "KAUiuQEKFldvcmtlckhlYXJ0YmVhdFJlcXVlc3QSNgoNc2h1dGRvd25fbW9k" + "ZRgBIAEoDjIfLnRlbnNvcmJvYXJkLldvcmtlclNodXRkb3duTW9kZRI0Cg93" + "YXRjaGRvZ19jb25maWcYAiABKAsyGy50ZW5zb3Jib2FyZC5XYXRjaGRvZ0Nv" + "bmZpZxIxCglleGl0X2NvZGUYAyABKAsyHi50ZW5zb3Jib2FyZC5SZXF1ZXN0" + "ZWRFeGl0Q29kZSKFAQoXV29ya2VySGVhcnRiZWF0UmVzcG9uc2USMAoNaGVh" + "bHRoX3N0YXR1cxgBIAEoDjIZLnRlbnNvcmJvYXJkLldvcmtlckhlYWx0aBIm" + "Cgp3b3JrZXJfbG9nGAIgAygLMhIudGVuc29yYm9hcmQuRXZlbnQSEAoIaG9z" + "dG5hbWUYAyABKAkqWwoMV29ya2VySGVhbHRoEgYKAk9LEAASHAoYUkVDRUlW" + "RURfU0hVVERPV05fU0lHTkFMEAESEgoOSU5URVJOQUxfRVJST1IQAhIRCg1T" + "SFVUVElOR19ET1dOEAMqawoSV29ya2VyU2h1dGRvd25Nb2RlEgsKB0RFRkFV" + "TFQQABISCg5OT1RfQ09ORklHVVJFRBABEhgKFFdBSVRfRk9SX0NPT1JESU5B" + "VE9SEAISGgoWU0hVVERPV05fQUZURVJfVElNRU9VVBADQnAKE29yZy50ZW5z" + "b3JmbG93LnV0aWxCC0V2ZW50UHJvdG9zUAFaR2dpdGh1Yi5jb20vdGVuc29y" + "Zmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28vY29yZS91dGlsL2V2ZW50" + "X2dvX3Byb3Rv+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[1] { SummaryReflection.Descriptor }, new GeneratedClrTypeInfo(new Type[2]
			{
				typeof(WorkerHealth),
				typeof(WorkerShutdownMode)
			}, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[8]
			{
				new GeneratedClrTypeInfo(typeof(Event), (MessageParser)(object)Event.Parser, new string[9] { "WallTime", "Step", "FileVersion", "GraphDef", "Summary", "LogMessage", "SessionLog", "TaggedRunMetadata", "MetaGraphDef" }, new string[1] { "What" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(LogMessage), (MessageParser)(object)LogMessage.Parser, new string[2] { "Level", "Message" }, (string[])null, new Type[1] { typeof(LogMessage.Types.Level) }, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SessionLog), (MessageParser)(object)SessionLog.Parser, new string[3] { "Status", "CheckpointPath", "Msg" }, (string[])null, new Type[1] { typeof(SessionLog.Types.SessionStatus) }, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(TaggedRunMetadata), (MessageParser)(object)TaggedRunMetadata.Parser, new string[2] { "Tag", "RunMetadata" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(WatchdogConfig), (MessageParser)(object)WatchdogConfig.Parser, new string[1] { "TimeoutMs" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(RequestedExitCode), (MessageParser)(object)RequestedExitCode.Parser, new string[1] { "ExitCode" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(WorkerHeartbeatRequest), (MessageParser)(object)WorkerHeartbeatRequest.Parser, new string[3] { "ShutdownMode", "WatchdogConfig", "ExitCode" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(WorkerHeartbeatResponse), (MessageParser)(object)WorkerHeartbeatResponse.Parser, new string[3] { "HealthStatus", "WorkerLog", "Hostname" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public enum WorkerHealth
	{
		[OriginalName("OK")]
		Ok,
		[OriginalName("RECEIVED_SHUTDOWN_SIGNAL")]
		ReceivedShutdownSignal,
		[OriginalName("INTERNAL_ERROR")]
		InternalError,
		[OriginalName("SHUTTING_DOWN")]
		ShuttingDown
	}
	public enum WorkerShutdownMode
	{
		[OriginalName("DEFAULT")]
		Default,
		[OriginalName("NOT_CONFIGURED")]
		NotConfigured,
		[OriginalName("WAIT_FOR_COORDINATOR")]
		WaitForCoordinator,
		[OriginalName("SHUTDOWN_AFTER_TIMEOUT")]
		ShutdownAfterTimeout
	}
	public sealed class Event : IMessage<Event>, IMessage, IEquatable<Event>, IDeepCloneable<Event>
	{
		public enum WhatOneofCase
		{
			None = 0,
			FileVersion = 3,
			GraphDef = 4,
			Summary = 5,
			LogMessage = 6,
			SessionLog = 7,
			TaggedRunMetadata = 8,
			MetaGraphDef = 9
		}

		private static readonly MessageParser<Event> _parser = new MessageParser<Event>((Func<Event>)(() => new Event()));

		private UnknownFieldSet _unknownFields;

		public const int WallTimeFieldNumber = 1;

		private double wallTime_;

		public const int StepFieldNumber = 2;

		private long step_;

		public const int FileVersionFieldNumber = 3;

		public const int GraphDefFieldNumber = 4;

		public const int SummaryFieldNumber = 5;

		public const int LogMessageFieldNumber = 6;

		public const int SessionLogFieldNumber = 7;

		public const int TaggedRunMetadataFieldNumber = 8;

		public const int MetaGraphDefFieldNumber = 9;

		private object what_;

		private WhatOneofCase whatCase_;

		[DebuggerNonUserCode]
		public static MessageParser<Event> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public double WallTime
		{
			get
			{
				return wallTime_;
			}
			set
			{
				wallTime_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long Step
		{
			get
			{
				return step_;
			}
			set
			{
				step_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string FileVersion
		{
			get
			{
				if (whatCase_ != WhatOneofCase.FileVersion)
				{
					return "";
				}
				return (string)what_;
			}
			set
			{
				what_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
				whatCase_ = WhatOneofCase.FileVersion;
			}
		}

		[DebuggerNonUserCode]
		public ByteString GraphDef
		{
			get
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_001b: Expected O, but got Unknown
				if (whatCase_ != WhatOneofCase.GraphDef)
				{
					return ByteString.Empty;
				}
				return (ByteString)what_;
			}
			set
			{
				what_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
				whatCase_ = WhatOneofCase.GraphDef;
			}
		}

		[DebuggerNonUserCode]
		public Summary Summary
		{
			get
			{
				if (whatCase_ != WhatOneofCase.Summary)
				{
					return null;
				}
				return (Summary)what_;
			}
			set
			{
				what_ = value;
				whatCase_ = ((value != null) ? WhatOneofCase.Summary : WhatOneofCase.None);
			}
		}

		[Obsolete]
		[DebuggerNonUserCode]
		public LogMessage LogMessage
		{
			get
			{
				if (whatCase_ != WhatOneofCase.LogMessage)
				{
					return null;
				}
				return (LogMessage)what_;
			}
			set
			{
				what_ = value;
				whatCase_ = ((value != null) ? WhatOneofCase.LogMessage : WhatOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SessionLog SessionLog
		{
			get
			{
				if (whatCase_ != WhatOneofCase.SessionLog)
				{
					return null;
				}
				return (SessionLog)what_;
			}
			set
			{
				what_ = value;
				whatCase_ = ((value != null) ? WhatOneofCase.SessionLog : WhatOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public TaggedRunMetadata TaggedRunMetadata
		{
			get
			{
				if (whatCase_ != WhatOneofCase.TaggedRunMetadata)
				{
					return null;
				}
				return (TaggedRunMetadata)what_;
			}
			set
			{
				what_ = value;
				whatCase_ = ((value != null) ? WhatOneofCase.TaggedRunMetadata : WhatOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public ByteString MetaGraphDef
		{
			get
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Expected O, but got Unknown
				if (whatCase_ != WhatOneofCase.MetaGraphDef)
				{
					return ByteString.Empty;
				}
				return (ByteString)what_;
			}
			set
			{
				what_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
				whatCase_ = WhatOneofCase.MetaGraphDef;
			}
		}

		[DebuggerNonUserCode]
		public WhatOneofCase WhatCase => whatCase_;

		[DebuggerNonUserCode]
		public Event()
		{
		}

		[DebuggerNonUserCode]
		public Event(Event other)
			: this()
		{
			wallTime_ = other.wallTime_;
			step_ = other.step_;
			switch (other.WhatCase)
			{
			case WhatOneofCase.FileVersion:
				FileVersion = other.FileVersion;
				break;
			case WhatOneofCase.GraphDef:
				GraphDef = other.GraphDef;
				break;
			case WhatOneofCase.Summary:
				Summary = other.Summary.Clone();
				break;
			case WhatOneofCase.LogMessage:
				LogMessage = other.LogMessage.Clone();
				break;
			case WhatOneofCase.SessionLog:
				SessionLog = other.SessionLog.Clone();
				break;
			case WhatOneofCase.TaggedRunMetadata:
				TaggedRunMetadata = other.TaggedRunMetadata.Clone();
				break;
			case WhatOneofCase.MetaGraphDef:
				MetaGraphDef = other.MetaGraphDef;
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public Event Clone()
		{
			return new Event(this);
		}

		[DebuggerNonUserCode]
		public void ClearWhat()
		{
			whatCase_ = WhatOneofCase.None;
			what_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as Event);
		}

		[DebuggerNonUserCode]
		public bool Equals(Event other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(WallTime, other.WallTime))
			{
				return false;
			}
			if (Step != other.Step)
			{
				return false;
			}
			if (FileVersion != other.FileVersion)
			{
				return false;
			}
			if (GraphDef != other.GraphDef)
			{
				return false;
			}
			if (!object.Equals(Summary, other.Summary))
			{
				return false;
			}
			if (!object.Equals(LogMessage, other.LogMessage))
			{
				return false;
			}
			if (!object.Equals(SessionLog, other.SessionLog))
			{
				return false;
			}
			if (!object.Equals(TaggedRunMetadata, other.TaggedRunMetadata))
			{
				return false;
			}
			if (MetaGraphDef != other.MetaGraphDef)
			{
				return false;
			}
			if (WhatCase != other.WhatCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (WallTime != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(WallTime);
			}
			if (Step != 0L)
			{
				num ^= Step.GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.FileVersion)
			{
				num ^= FileVersion.GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.GraphDef)
			{
				num ^= ((object)GraphDef).GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.Summary)
			{
				num ^= Summary.GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.LogMessage)
			{
				num ^= LogMessage.GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.SessionLog)
			{
				num ^= SessionLog.GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.TaggedRunMetadata)
			{
				num ^= TaggedRunMetadata.GetHashCode();
			}
			if (whatCase_ == WhatOneofCase.MetaGraphDef)
			{
				num ^= ((object)MetaGraphDef).GetHashCode();
			}
			num ^= (int)whatCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (WallTime != 0.0)
			{
				output.WriteRawTag((byte)9);
				output.WriteDouble(WallTime);
			}
			if (Step != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(Step);
			}
			if (whatCase_ == WhatOneofCase.FileVersion)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(FileVersion);
			}
			if (whatCase_ == WhatOneofCase.GraphDef)
			{
				output.WriteRawTag((byte)34);
				output.WriteBytes(GraphDef);
			}
			if (whatCase_ == WhatOneofCase.Summary)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)Summary);
			}
			if (whatCase_ == WhatOneofCase.LogMessage)
			{
				output.WriteRawTag((byte)50);
				output.WriteMessage((IMessage)(object)LogMessage);
			}
			if (whatCase_ == WhatOneofCase.SessionLog)
			{
				output.WriteRawTag((byte)58);
				output.WriteMessage((IMessage)(object)SessionLog);
			}
			if (whatCase_ == WhatOneofCase.TaggedRunMetadata)
			{
				output.WriteRawTag((byte)66);
				output.WriteMessage((IMessage)(object)TaggedRunMetadata);
			}
			if (whatCase_ == WhatOneofCase.MetaGraphDef)
			{
				output.WriteRawTag((byte)74);
				output.WriteBytes(MetaGraphDef);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (WallTime != 0.0)
			{
				num += 9;
			}
			if (Step != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Step);
			}
			if (whatCase_ == WhatOneofCase.FileVersion)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FileVersion);
			}
			if (whatCase_ == WhatOneofCase.GraphDef)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(GraphDef);
			}
			if (whatCase_ == WhatOneofCase.Summary)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Summary);
			}
			if (whatCase_ == WhatOneofCase.LogMessage)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)LogMessage);
			}
			if (whatCase_ == WhatOneofCase.SessionLog)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)SessionLog);
			}
			if (whatCase_ == WhatOneofCase.TaggedRunMetadata)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TaggedRunMetadata);
			}
			if (whatCase_ == WhatOneofCase.MetaGraphDef)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(MetaGraphDef);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(Event other)
		{
			if (other == null)
			{
				return;
			}
			if (other.WallTime != 0.0)
			{
				WallTime = other.WallTime;
			}
			if (other.Step != 0L)
			{
				Step = other.Step;
			}
			switch (other.WhatCase)
			{
			case WhatOneofCase.FileVersion:
				FileVersion = other.FileVersion;
				break;
			case WhatOneofCase.GraphDef:
				GraphDef = other.GraphDef;
				break;
			case WhatOneofCase.Summary:
				if (Summary == null)
				{
					Summary = new Summary();
				}
				Summary.MergeFrom(other.Summary);
				break;
			case WhatOneofCase.LogMessage:
				if (LogMessage == null)
				{
					LogMessage = new LogMessage();
				}
				LogMessage.MergeFrom(other.LogMessage);
				break;
			case WhatOneofCase.SessionLog:
				if (SessionLog == null)
				{
					SessionLog = new SessionLog();
				}
				SessionLog.MergeFrom(other.SessionLog);
				break;
			case WhatOneofCase.TaggedRunMetadata:
				if (TaggedRunMetadata == null)
				{
					TaggedRunMetadata = new TaggedRunMetadata();
				}
				TaggedRunMetadata.MergeFrom(other.TaggedRunMetadata);
				break;
			case WhatOneofCase.MetaGraphDef:
				MetaGraphDef = other.MetaGraphDef;
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 9u:
					WallTime = input.ReadDouble();
					break;
				case 16u:
					Step = input.ReadInt64();
					break;
				case 26u:
					FileVersion = input.ReadString();
					break;
				case 34u:
					GraphDef = input.ReadBytes();
					break;
				case 42u:
				{
					Summary summary = new Summary();
					if (whatCase_ == WhatOneofCase.Summary)
					{
						summary.MergeFrom(Summary);
					}
					input.ReadMessage((IMessage)(object)summary);
					Summary = summary;
					break;
				}
				case 50u:
				{
					LogMessage logMessage = new LogMessage();
					if (whatCase_ == WhatOneofCase.LogMessage)
					{
						logMessage.MergeFrom(LogMessage);
					}
					input.ReadMessage((IMessage)(object)logMessage);
					LogMessage = logMessage;
					break;
				}
				case 58u:
				{
					SessionLog sessionLog = new SessionLog();
					if (whatCase_ == WhatOneofCase.SessionLog)
					{
						sessionLog.MergeFrom(SessionLog);
					}
					input.ReadMessage((IMessage)(object)sessionLog);
					SessionLog = sessionLog;
					break;
				}
				case 66u:
				{
					TaggedRunMetadata taggedRunMetadata = new TaggedRunMetadata();
					if (whatCase_ == WhatOneofCase.TaggedRunMetadata)
					{
						taggedRunMetadata.MergeFrom(TaggedRunMetadata);
					}
					input.ReadMessage((IMessage)(object)taggedRunMetadata);
					TaggedRunMetadata = taggedRunMetadata;
					break;
				}
				case 74u:
					MetaGraphDef = input.ReadBytes();
					break;
				}
			}
		}
	}
	[Obsolete]
	public sealed class LogMessage : IMessage<LogMessage>, IMessage, IEquatable<LogMessage>, IDeepCloneable<LogMessage>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum Level
			{
				[OriginalName("UNKNOWN")]
				Unknown = 0,
				[OriginalName("DEBUGGING")]
				Debugging = 10,
				[OriginalName("INFO")]
				Info = 20,
				[OriginalName("WARN")]
				Warn = 30,
				[OriginalName("ERROR")]
				Error = 40,
				[OriginalName("FATAL")]
				Fatal = 50
			}
		}

		private static readonly MessageParser<LogMessage> _parser = new MessageParser<LogMessage>((Func<LogMessage>)(() => new LogMessage()));

		private UnknownFieldSet _unknownFields;

		public const int LevelFieldNumber = 1;

		private Types.Level level_;

		public const int MessageFieldNumber = 2;

		private string message_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<LogMessage> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.Level Level
		{
			get
			{
				return level_;
			}
			set
			{
				level_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string Message
		{
			get
			{
				return message_;
			}
			set
			{
				message_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public LogMessage()
		{
		}

		[DebuggerNonUserCode]
		public LogMessage(LogMessage other)
			: this()
		{
			level_ = other.level_;
			message_ = other.message_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public LogMessage Clone()
		{
			return new LogMessage(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as LogMessage);
		}

		[DebuggerNonUserCode]
		public bool Equals(LogMessage other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Level != other.Level)
			{
				return false;
			}
			if (Message != other.Message)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Level != Types.Level.Unknown)
			{
				num ^= Level.GetHashCode();
			}
			if (Message.Length != 0)
			{
				num ^= Message.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Level != Types.Level.Unknown)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)Level);
			}
			if (Message.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(Message);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Level != Types.Level.Unknown)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Level);
			}
			if (Message.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Message);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(LogMessage other)
		{
			if (other != null)
			{
				if (other.Level != Types.Level.Unknown)
				{
					Level = other.Level;
				}
				if (other.Message.Length != 0)
				{
					Message = other.Message;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Level = (Types.Level)input.ReadEnum();
					break;
				case 18u:
					Message = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class SessionLog : IMessage<SessionLog>, IMessage, IEquatable<SessionLog>, IDeepCloneable<SessionLog>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum SessionStatus
			{
				[OriginalName("STATUS_UNSPECIFIED")]
				StatusUnspecified,
				[OriginalName("START")]
				Start,
				[OriginalName("STOP")]
				Stop,
				[OriginalName("CHECKPOINT")]
				Checkpoint
			}
		}

		private static readonly MessageParser<SessionLog> _parser = new MessageParser<SessionLog>((Func<SessionLog>)(() => new SessionLog()));

		private UnknownFieldSet _unknownFields;

		public const int StatusFieldNumber = 1;

		private Types.SessionStatus status_;

		public const int CheckpointPathFieldNumber = 2;

		private string checkpointPath_ = "";

		public const int MsgFieldNumber = 3;

		private string msg_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<SessionLog> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.SessionStatus Status
		{
			get
			{
				return status_;
			}
			set
			{
				status_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string CheckpointPath
		{
			get
			{
				return checkpointPath_;
			}
			set
			{
				checkpointPath_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Msg
		{
			get
			{
				return msg_;
			}
			set
			{
				msg_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SessionLog()
		{
		}

		[DebuggerNonUserCode]
		public SessionLog(SessionLog other)
			: this()
		{
			status_ = other.status_;
			checkpointPath_ = other.checkpointPath_;
			msg_ = other.msg_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SessionLog Clone()
		{
			return new SessionLog(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SessionLog);
		}

		[DebuggerNonUserCode]
		public bool Equals(SessionLog other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Status != other.Status)
			{
				return false;
			}
			if (CheckpointPath != other.CheckpointPath)
			{
				return false;
			}
			if (Msg != other.Msg)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Status != Types.SessionStatus.StatusUnspecified)
			{
				num ^= Status.GetHashCode();
			}
			if (CheckpointPath.Length != 0)
			{
				num ^= CheckpointPath.GetHashCode();
			}
			if (Msg.Length != 0)
			{
				num ^= Msg.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Status != Types.SessionStatus.StatusUnspecified)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)Status);
			}
			if (CheckpointPath.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(CheckpointPath);
			}
			if (Msg.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(Msg);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Status != Types.SessionStatus.StatusUnspecified)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Status);
			}
			if (CheckpointPath.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(CheckpointPath);
			}
			if (Msg.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Msg);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SessionLog other)
		{
			if (other != null)
			{
				if (other.Status != Types.SessionStatus.StatusUnspecified)
				{
					Status = other.Status;
				}
				if (other.CheckpointPath.Length != 0)
				{
					CheckpointPath = other.CheckpointPath;
				}
				if (other.Msg.Length != 0)
				{
					Msg = other.Msg;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Status = (Types.SessionStatus)input.ReadEnum();
					break;
				case 18u:
					CheckpointPath = input.ReadString();
					break;
				case 26u:
					Msg = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class TaggedRunMetadata : IMessage<TaggedRunMetadata>, IMessage, IEquatable<TaggedRunMetadata>, IDeepCloneable<TaggedRunMetadata>
	{
		private static readonly MessageParser<TaggedRunMetadata> _parser = new MessageParser<TaggedRunMetadata>((Func<TaggedRunMetadata>)(() => new TaggedRunMetadata()));

		private UnknownFieldSet _unknownFields;

		public const int TagFieldNumber = 1;

		private string tag_ = "";

		public const int RunMetadataFieldNumber = 2;

		private ByteString runMetadata_ = ByteString.Empty;

		[DebuggerNonUserCode]
		public static MessageParser<TaggedRunMetadata> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Tag
		{
			get
			{
				return tag_;
			}
			set
			{
				tag_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public ByteString RunMetadata
		{
			get
			{
				return runMetadata_;
			}
			set
			{
				runMetadata_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public TaggedRunMetadata()
		{
		}

		[DebuggerNonUserCode]
		public TaggedRunMetadata(TaggedRunMetadata other)
			: this()
		{
			tag_ = other.tag_;
			runMetadata_ = other.runMetadata_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TaggedRunMetadata Clone()
		{
			return new TaggedRunMetadata(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TaggedRunMetadata);
		}

		[DebuggerNonUserCode]
		public bool Equals(TaggedRunMetadata other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Tag != other.Tag)
			{
				return false;
			}
			if (RunMetadata != other.RunMetadata)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Tag.Length != 0)
			{
				num ^= Tag.GetHashCode();
			}
			if (RunMetadata.Length != 0)
			{
				num ^= ((object)RunMetadata).GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Tag.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Tag);
			}
			if (RunMetadata.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteBytes(RunMetadata);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Tag.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Tag);
			}
			if (RunMetadata.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(RunMetadata);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TaggedRunMetadata other)
		{
			if (other != null)
			{
				if (other.Tag.Length != 0)
				{
					Tag = other.Tag;
				}
				if (other.RunMetadata.Length != 0)
				{
					RunMetadata = other.RunMetadata;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Tag = input.ReadString();
					break;
				case 18u:
					RunMetadata = input.ReadBytes();
					break;
				}
			}
		}
	}
	public sealed class WatchdogConfig : IMessage<WatchdogConfig>, IMessage, IEquatable<WatchdogConfig>, IDeepCloneable<WatchdogConfig>
	{
		private static readonly MessageParser<WatchdogConfig> _parser = new MessageParser<WatchdogConfig>((Func<WatchdogConfig>)(() => new WatchdogConfig()));

		private UnknownFieldSet _unknownFields;

		public const int TimeoutMsFieldNumber = 1;

		private long timeoutMs_;

		[DebuggerNonUserCode]
		public static MessageParser<WatchdogConfig> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long TimeoutMs
		{
			get
			{
				return timeoutMs_;
			}
			set
			{
				timeoutMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public WatchdogConfig()
		{
		}

		[DebuggerNonUserCode]
		public WatchdogConfig(WatchdogConfig other)
			: this()
		{
			timeoutMs_ = other.timeoutMs_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public WatchdogConfig Clone()
		{
			return new WatchdogConfig(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as WatchdogConfig);
		}

		[DebuggerNonUserCode]
		public bool Equals(WatchdogConfig other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TimeoutMs != other.TimeoutMs)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TimeoutMs != 0L)
			{
				num ^= TimeoutMs.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TimeoutMs != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(TimeoutMs);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TimeoutMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(TimeoutMs);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(WatchdogConfig other)
		{
			if (other != null)
			{
				if (other.TimeoutMs != 0L)
				{
					TimeoutMs = other.TimeoutMs;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					TimeoutMs = input.ReadInt64();
				}
			}
		}
	}
	public sealed class RequestedExitCode : IMessage<RequestedExitCode>, IMessage, IEquatable<RequestedExitCode>, IDeepCloneable<RequestedExitCode>
	{
		private static readonly MessageParser<RequestedExitCode> _parser = new MessageParser<RequestedExitCode>((Func<RequestedExitCode>)(() => new RequestedExitCode()));

		private UnknownFieldSet _unknownFields;

		public const int ExitCodeFieldNumber = 1;

		private int exitCode_;

		[DebuggerNonUserCode]
		public static MessageParser<RequestedExitCode> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int ExitCode
		{
			get
			{
				return exitCode_;
			}
			set
			{
				exitCode_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RequestedExitCode()
		{
		}

		[DebuggerNonUserCode]
		public RequestedExitCode(RequestedExitCode other)
			: this()
		{
			exitCode_ = other.exitCode_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RequestedExitCode Clone()
		{
			return new RequestedExitCode(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RequestedExitCode);
		}

		[DebuggerNonUserCode]
		public bool Equals(RequestedExitCode other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ExitCode != other.ExitCode)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (ExitCode != 0)
			{
				num ^= ExitCode.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (ExitCode != 0)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt32(ExitCode);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (ExitCode != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(ExitCode);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RequestedExitCode other)
		{
			if (other != null)
			{
				if (other.ExitCode != 0)
				{
					ExitCode = other.ExitCode;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					ExitCode = input.ReadInt32();
				}
			}
		}
	}
	public sealed class WorkerHeartbeatRequest : IMessage<WorkerHeartbeatRequest>, IMessage, IEquatable<WorkerHeartbeatRequest>, IDeepCloneable<WorkerHeartbeatRequest>
	{
		private static readonly MessageParser<WorkerHeartbeatRequest> _parser = new MessageParser<WorkerHeartbeatRequest>((Func<WorkerHeartbeatRequest>)(() => new WorkerHeartbeatRequest()));

		private UnknownFieldSet _unknownFields;

		public const int ShutdownModeFieldNumber = 1;

		private WorkerShutdownMode shutdownMode_;

		public const int WatchdogConfigFieldNumber = 2;

		private WatchdogConfig watchdogConfig_;

		public const int ExitCodeFieldNumber = 3;

		private RequestedExitCode exitCode_;

		[DebuggerNonUserCode]
		public static MessageParser<WorkerHeartbeatRequest> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public WorkerShutdownMode ShutdownMode
		{
			get
			{
				return shutdownMode_;
			}
			set
			{
				shutdownMode_ = value;
			}
		}

		[DebuggerNonUserCode]
		public WatchdogConfig WatchdogConfig
		{
			get
			{
				return watchdogConfig_;
			}
			set
			{
				watchdogConfig_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RequestedExitCode ExitCode
		{
			get
			{
				return exitCode_;
			}
			set
			{
				exitCode_ = value;
			}
		}

		[DebuggerNonUserCode]
		public WorkerHeartbeatRequest()
		{
		}

		[DebuggerNonUserCode]
		public WorkerHeartbeatRequest(WorkerHeartbeatRequest other)
			: this()
		{
			shutdownMode_ = other.shutdownMode_;
			watchdogConfig_ = ((other.watchdogConfig_ != null) ? other.watchdogConfig_.Clone() : null);
			exitCode_ = ((other.exitCode_ != null) ? other.exitCode_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public WorkerHeartbeatRequest Clone()
		{
			return new WorkerHeartbeatRequest(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as WorkerHeartbeatRequest);
		}

		[DebuggerNonUserCode]
		public bool Equals(WorkerHeartbeatRequest other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ShutdownMode != other.ShutdownMode)
			{
				return false;
			}
			if (!object.Equals(WatchdogConfig, other.WatchdogConfig))
			{
				return false;
			}
			if (!object.Equals(ExitCode, other.ExitCode))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (ShutdownMode != WorkerShutdownMode.Default)
			{
				num ^= ShutdownMode.GetHashCode();
			}
			if (watchdogConfig_ != null)
			{
				num ^= WatchdogConfig.GetHashCode();
			}
			if (exitCode_ != null)
			{
				num ^= ExitCode.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (ShutdownMode != WorkerShutdownMode.Default)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)ShutdownMode);
			}
			if (watchdogConfig_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)WatchdogConfig);
			}
			if (exitCode_ != null)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)ExitCode);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (ShutdownMode != WorkerShutdownMode.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)ShutdownMode);
			}
			if (watchdogConfig_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)WatchdogConfig);
			}
			if (exitCode_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ExitCode);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(WorkerHeartbeatRequest other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ShutdownMode != WorkerShutdownMode.Default)
			{
				ShutdownMode = other.ShutdownMode;
			}
			if (other.watchdogConfig_ != null)
			{
				if (watchdogConfig_ == null)
				{
					WatchdogConfig = new WatchdogConfig();
				}
				WatchdogConfig.MergeFrom(other.WatchdogConfig);
			}
			if (other.exitCode_ != null)
			{
				if (exitCode_ == null)
				{
					ExitCode = new RequestedExitCode();
				}
				ExitCode.MergeFrom(other.ExitCode);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					ShutdownMode = (WorkerShutdownMode)input.ReadEnum();
					break;
				case 18u:
					if (watchdogConfig_ == null)
					{
						WatchdogConfig = new WatchdogConfig();
					}
					input.ReadMessage((IMessage)(object)WatchdogConfig);
					break;
				case 26u:
					if (exitCode_ == null)
					{
						ExitCode = new RequestedExitCode();
					}
					input.ReadMessage((IMessage)(object)ExitCode);
					break;
				}
			}
		}
	}
	public sealed class WorkerHeartbeatResponse : IMessage<WorkerHeartbeatResponse>, IMessage, IEquatable<WorkerHeartbeatResponse>, IDeepCloneable<WorkerHeartbeatResponse>
	{
		private static readonly MessageParser<WorkerHeartbeatResponse> _parser = new MessageParser<WorkerHeartbeatResponse>((Func<WorkerHeartbeatResponse>)(() => new WorkerHeartbeatResponse()));

		private UnknownFieldSet _unknownFields;

		public const int HealthStatusFieldNumber = 1;

		private WorkerHealth healthStatus_;

		public const int WorkerLogFieldNumber = 2;

		private static readonly FieldCodec<Event> _repeated_workerLog_codec = FieldCodec.ForMessage<Event>(18u, Event.Parser);

		private readonly RepeatedField<Event> workerLog_ = new RepeatedField<Event>();

		public const int HostnameFieldNumber = 3;

		private string hostname_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<WorkerHeartbeatResponse> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => EventReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public WorkerHealth HealthStatus
		{
			get
			{
				return healthStatus_;
			}
			set
			{
				healthStatus_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<Event> WorkerLog => workerLog_;

		[DebuggerNonUserCode]
		public string Hostname
		{
			get
			{
				return hostname_;
			}
			set
			{
				hostname_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public WorkerHeartbeatResponse()
		{
		}

		[DebuggerNonUserCode]
		public WorkerHeartbeatResponse(WorkerHeartbeatResponse other)
			: this()
		{
			healthStatus_ = other.healthStatus_;
			workerLog_ = other.workerLog_.Clone();
			hostname_ = other.hostname_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public WorkerHeartbeatResponse Clone()
		{
			return new WorkerHeartbeatResponse(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as WorkerHeartbeatResponse);
		}

		[DebuggerNonUserCode]
		public bool Equals(WorkerHeartbeatResponse other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (HealthStatus != other.HealthStatus)
			{
				return false;
			}
			if (!workerLog_.Equals(other.workerLog_))
			{
				return false;
			}
			if (Hostname != other.Hostname)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (HealthStatus != WorkerHealth.Ok)
			{
				num ^= HealthStatus.GetHashCode();
			}
			num ^= ((object)workerLog_).GetHashCode();
			if (Hostname.Length != 0)
			{
				num ^= Hostname.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (HealthStatus != WorkerHealth.Ok)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)HealthStatus);
			}
			workerLog_.WriteTo(output, _repeated_workerLog_codec);
			if (Hostname.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(Hostname);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (HealthStatus != WorkerHealth.Ok)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)HealthStatus);
			}
			num += workerLog_.CalculateSize(_repeated_workerLog_codec);
			if (Hostname.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Hostname);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(WorkerHeartbeatResponse other)
		{
			if (other != null)
			{
				if (other.HealthStatus != WorkerHealth.Ok)
				{
					HealthStatus = other.HealthStatus;
				}
				workerLog_.Add((IEnumerable<Event>)other.workerLog_);
				if (other.Hostname.Length != 0)
				{
					Hostname = other.Hostname;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					HealthStatus = (WorkerHealth)input.ReadEnum();
					break;
				case 18u:
					workerLog_.AddEntriesFrom(input, _repeated_workerLog_codec);
					break;
				case 26u:
					Hostname = input.ReadString();
					break;
				}
			}
		}
	}
	public static class FullTypeReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static FullTypeReflection()
		{
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cih0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vZnVsbF90eXBlLnByb3RvEgt0" + "ZW5zb3Jib2FyZCKBAQoLRnVsbFR5cGVEZWYSKAoHdHlwZV9pZBgBIAEoDjIX" + "LnRlbnNvcmJvYXJkLkZ1bGxUeXBlSWQSJgoEYXJncxgCIAMoCzIYLnRlbnNv" + "cmJvYXJkLkZ1bGxUeXBlRGVmEgsKAXMYAyABKAlIABILCgFpGAQgASgDSABC" + "BgoEYXR0ciqeBAoKRnVsbFR5cGVJZBINCglURlRfVU5TRVQQABILCgdURlRf" + "VkFSEAESCwoHVEZUX0FOWRACEg8KC1RGVF9QUk9EVUNUEAMSDQoJVEZUX05B" + "TUVEEAQSEAoMVEZUX0ZPUl9FQUNIEBQSEAoMVEZUX0NBTExBQkxFEGQSDwoK" + "VEZUX1RFTlNPUhDoBxIOCglURlRfQVJSQVkQ6QcSEQoMVEZUX09QVElPTkFM" + "EOoHEhAKC1RGVF9MSVRFUkFMEOsHEg0KCFRGVF9CT09MEMgBEg4KCVRGVF9V" + "SU5UOBDJARIPCgpURlRfVUlOVDE2EMoBEg8KClRGVF9VSU5UMzIQywESDwoK" + "VEZUX1VJTlQ2NBDMARINCghURlRfSU5UOBDNARIOCglURlRfSU5UMTYQzgES" + "DgoJVEZUX0lOVDMyEM8BEg4KCVRGVF9JTlQ2NBDQARINCghURlRfSEFMRhDR" + "ARIOCglURlRfRkxPQVQQ0gESDwoKVEZUX0RPVUJMRRDTARIRCgxURlRfQkZM" + "T0FUMTYQ1wESEgoNVEZUX0NPTVBMRVg2NBDUARITCg5URlRfQ09NUExFWDEy" + "OBDVARIPCgpURlRfU1RSSU5HENYBEhAKC1RGVF9EQVRBU0VUEPZOEg8KClRG" + "VF9SQUdHRUQQ904SEwoOVEZUX01VVEVYX0xPQ0sQ2k8SFwoSVEZUX0xFR0FD" + "WV9WQVJJQU5UENtPQoEBChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDkZ1" + "bGxUeXBlUHJvdG9zUAFaUGdpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3Jm" + "bG93L3RlbnNvcmZsb3cvZ28vY29yZS9mcmFtZXdvcmsvZnVsbF90eXBlX2dv" + "X3Byb3Rv+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo(new Type[1] { typeof(FullTypeId) }, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(FullTypeDef), (MessageParser)(object)FullTypeDef.Parser, new string[4] { "TypeId", "Args", "S", "I" }, new string[1] { "Attr" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public enum FullTypeId
	{
		[OriginalName("TFT_UNSET")]
		TftUnset = 0,
		[OriginalName("TFT_VAR")]
		TftVar = 1,
		[OriginalName("TFT_ANY")]
		TftAny = 2,
		[OriginalName("TFT_PRODUCT")]
		TftProduct = 3,
		[OriginalName("TFT_NAMED")]
		TftNamed = 4,
		[OriginalName("TFT_FOR_EACH")]
		TftForEach = 20,
		[OriginalName("TFT_CALLABLE")]
		TftCallable = 100,
		[OriginalName("TFT_TENSOR")]
		TftTensor = 1000,
		[OriginalName("TFT_ARRAY")]
		TftArray = 1001,
		[OriginalName("TFT_OPTIONAL")]
		TftOptional = 1002,
		[OriginalName("TFT_LITERAL")]
		TftLiteral = 1003,
		[OriginalName("TFT_BOOL")]
		TftBool = 200,
		[OriginalName("TFT_UINT8")]
		TftUint8 = 201,
		[OriginalName("TFT_UINT16")]
		TftUint16 = 202,
		[OriginalName("TFT_UINT32")]
		TftUint32 = 203,
		[OriginalName("TFT_UINT64")]
		TftUint64 = 204,
		[OriginalName("TFT_INT8")]
		TftInt8 = 205,
		[OriginalName("TFT_INT16")]
		TftInt16 = 206,
		[OriginalName("TFT_INT32")]
		TftInt32 = 207,
		[OriginalName("TFT_INT64")]
		TftInt64 = 208,
		[OriginalName("TFT_HALF")]
		TftHalf = 209,
		[OriginalName("TFT_FLOAT")]
		TftFloat = 210,
		[OriginalName("TFT_DOUBLE")]
		TftDouble = 211,
		[OriginalName("TFT_BFLOAT16")]
		TftBfloat16 = 215,
		[OriginalName("TFT_COMPLEX64")]
		TftComplex64 = 212,
		[OriginalName("TFT_COMPLEX128")]
		TftComplex128 = 213,
		[OriginalName("TFT_STRING")]
		TftString = 214,
		[OriginalName("TFT_DATASET")]
		TftDataset = 10102,
		[OriginalName("TFT_RAGGED")]
		TftRagged = 10103,
		[OriginalName("TFT_MUTEX_LOCK")]
		TftMutexLock = 10202,
		[OriginalName("TFT_LEGACY_VARIANT")]
		TftLegacyVariant = 10203
	}
	public sealed class FullTypeDef : IMessage<FullTypeDef>, IMessage, IEquatable<FullTypeDef>, IDeepCloneable<FullTypeDef>
	{
		public enum AttrOneofCase
		{
			None = 0,
			S = 3,
			I = 4
		}

		private static readonly MessageParser<FullTypeDef> _parser = new MessageParser<FullTypeDef>((Func<FullTypeDef>)(() => new FullTypeDef()));

		private UnknownFieldSet _unknownFields;

		public const int TypeIdFieldNumber = 1;

		private FullTypeId typeId_;

		public const int ArgsFieldNumber = 2;

		private static readonly FieldCodec<FullTypeDef> _repeated_args_codec = FieldCodec.ForMessage<FullTypeDef>(18u, Parser);

		private readonly RepeatedField<FullTypeDef> args_ = new RepeatedField<FullTypeDef>();

		public const int SFieldNumber = 3;

		public const int IFieldNumber = 4;

		private object attr_;

		private AttrOneofCase attrCase_;

		[DebuggerNonUserCode]
		public static MessageParser<FullTypeDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => FullTypeReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public FullTypeId TypeId
		{
			get
			{
				return typeId_;
			}
			set
			{
				typeId_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<FullTypeDef> Args => args_;

		[DebuggerNonUserCode]
		public string S
		{
			get
			{
				if (attrCase_ != AttrOneofCase.S)
				{
					return "";
				}
				return (string)attr_;
			}
			set
			{
				attr_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
				attrCase_ = AttrOneofCase.S;
			}
		}

		[DebuggerNonUserCode]
		public long I
		{
			get
			{
				if (attrCase_ != AttrOneofCase.I)
				{
					return 0L;
				}
				return (long)attr_;
			}
			set
			{
				attr_ = value;
				attrCase_ = AttrOneofCase.I;
			}
		}

		[DebuggerNonUserCode]
		public AttrOneofCase AttrCase => attrCase_;

		[DebuggerNonUserCode]
		public FullTypeDef()
		{
		}

		[DebuggerNonUserCode]
		public FullTypeDef(FullTypeDef other)
			: this()
		{
			typeId_ = other.typeId_;
			args_ = other.args_.Clone();
			switch (other.AttrCase)
			{
			case AttrOneofCase.S:
				S = other.S;
				break;
			case AttrOneofCase.I:
				I = other.I;
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public FullTypeDef Clone()
		{
			return new FullTypeDef(this);
		}

		[DebuggerNonUserCode]
		public void ClearAttr()
		{
			attrCase_ = AttrOneofCase.None;
			attr_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as FullTypeDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(FullTypeDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TypeId != other.TypeId)
			{
				return false;
			}
			if (!args_.Equals(other.args_))
			{
				return false;
			}
			if (S != other.S)
			{
				return false;
			}
			if (I != other.I)
			{
				return false;
			}
			if (AttrCase != other.AttrCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TypeId != FullTypeId.TftUnset)
			{
				num ^= TypeId.GetHashCode();
			}
			num ^= ((object)args_).GetHashCode();
			if (attrCase_ == AttrOneofCase.S)
			{
				num ^= S.GetHashCode();
			}
			if (attrCase_ == AttrOneofCase.I)
			{
				num ^= I.GetHashCode();
			}
			num ^= (int)attrCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TypeId != FullTypeId.TftUnset)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)TypeId);
			}
			args_.WriteTo(output, _repeated_args_codec);
			if (attrCase_ == AttrOneofCase.S)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(S);
			}
			if (attrCase_ == AttrOneofCase.I)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(I);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TypeId != FullTypeId.TftUnset)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)TypeId);
			}
			num += args_.CalculateSize(_repeated_args_codec);
			if (attrCase_ == AttrOneofCase.S)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(S);
			}
			if (attrCase_ == AttrOneofCase.I)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(I);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(FullTypeDef other)
		{
			if (other != null)
			{
				if (other.TypeId != FullTypeId.TftUnset)
				{
					TypeId = other.TypeId;
				}
				args_.Add((IEnumerable<FullTypeDef>)other.args_);
				switch (other.AttrCase)
				{
				case AttrOneofCase.S:
					S = other.S;
					break;
				case AttrOneofCase.I:
					I = other.I;
					break;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					TypeId = (FullTypeId)input.ReadEnum();
					break;
				case 18u:
					args_.AddEntriesFrom(input, _repeated_args_codec);
					break;
				case 26u:
					S = input.ReadString();
					break;
				case 32u:
					I = input.ReadInt64();
					break;
				}
			}
		}
	}
	public static class FunctionReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static FunctionReflection()
		{
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Expected O, but got Unknown
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Expected O, but got Unknown
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cid0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vZnVuY3Rpb24ucHJvdG8SC3Rl" + "bnNvcmJvYXJkGil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vYXR0cl92YWx1" + "ZS5wcm90bxondGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL25vZGVfZGVmLnBy" + "b3RvGiV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vb3BfZGVmLnByb3RvIqsB" + "ChJGdW5jdGlvbkRlZkxpYnJhcnkSKgoIZnVuY3Rpb24YASADKAsyGC50ZW5z" + "b3Jib2FyZC5GdW5jdGlvbkRlZhIqCghncmFkaWVudBgCIAMoCzIYLnRlbnNv" + "cmJvYXJkLkdyYWRpZW50RGVmEj0KFHJlZ2lzdGVyZWRfZ3JhZGllbnRzGAMg" + "AygLMh8udGVuc29yYm9hcmQuUmVnaXN0ZXJlZEdyYWRpZW50Is8GCgtGdW5j" + "dGlvbkRlZhIlCglzaWduYXR1cmUYASABKAsyEi50ZW5zb3Jib2FyZC5PcERl" + "ZhIwCgRhdHRyGAUgAygLMiIudGVuc29yYm9hcmQuRnVuY3Rpb25EZWYuQXR0" + "ckVudHJ5EjcKCGFyZ19hdHRyGAcgAygLMiUudGVuc29yYm9hcmQuRnVuY3Rp" + "b25EZWYuQXJnQXR0ckVudHJ5ElEKFnJlc291cmNlX2FyZ191bmlxdWVfaWQY" + "CCADKAsyMS50ZW5zb3Jib2FyZC5GdW5jdGlvbkRlZi5SZXNvdXJjZUFyZ1Vu" + "aXF1ZUlkRW50cnkSJgoIbm9kZV9kZWYYAyADKAsyFC50ZW5zb3Jib2FyZC5O" + "b2RlRGVmEi4KA3JldBgEIAMoCzIhLnRlbnNvcmJvYXJkLkZ1bmN0aW9uRGVm" + "LlJldEVudHJ5Ej0KC2NvbnRyb2xfcmV0GAYgAygLMigudGVuc29yYm9hcmQu" + "RnVuY3Rpb25EZWYuQ29udHJvbFJldEVudHJ5GkMKCUF0dHJFbnRyeRILCgNr" + "ZXkYASABKAkSJQoFdmFsdWUYAiABKAsyFi50ZW5zb3Jib2FyZC5BdHRyVmFs" + "dWU6AjgBGooBCghBcmdBdHRycxI5CgRhdHRyGAEgAygLMisudGVuc29yYm9h" + "cmQuRnVuY3Rpb25EZWYuQXJnQXR0cnMuQXR0ckVudHJ5GkMKCUF0dHJFbnRy" + "eRILCgNrZXkYASABKAkSJQoFdmFsdWUYAiABKAsyFi50ZW5zb3Jib2FyZC5B" + "dHRyVmFsdWU6AjgBGlEKDEFyZ0F0dHJFbnRyeRILCgNrZXkYASABKA0SMAoF" + "dmFsdWUYAiABKAsyIS50ZW5zb3Jib2FyZC5GdW5jdGlvbkRlZi5BcmdBdHRy" + "czoCOAEaOgoYUmVzb3VyY2VBcmdVbmlxdWVJZEVudHJ5EgsKA2tleRgBIAEo" + "DRINCgV2YWx1ZRgCIAEoDToCOAEaKgoIUmV0RW50cnkSCwoDa2V5GAEgASgJ" + "Eg0KBXZhbHVlGAIgASgJOgI4ARoxCg9Db250cm9sUmV0RW50cnkSCwoDa2V5" + "GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4AUoECAIQAyI7CgtHcmFkaWVudERl" + "ZhIVCg1mdW5jdGlvbl9uYW1lGAEgASgJEhUKDWdyYWRpZW50X2Z1bmMYAiAB" + "KAkiRwoSUmVnaXN0ZXJlZEdyYWRpZW50EhUKDWdyYWRpZW50X2Z1bmMYASAB" + "KAkSGgoScmVnaXN0ZXJlZF9vcF90eXBlGAIgASgJQoABChhvcmcudGVuc29y" + "Zmxvdy5mcmFtZXdvcmtCDkZ1bmN0aW9uUHJvdG9zUAFaT2dpdGh1Yi5jb20v" + "dGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28vY29yZS9mcmFt" + "ZXdvcmsvZnVuY3Rpb25fZ29fcHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				AttrValueReflection.Descriptor,
				NodeDefReflection.Descriptor,
				OpDefReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[4]
			{
				new GeneratedClrTypeInfo(typeof(FunctionDefLibrary), (MessageParser)(object)FunctionDefLibrary.Parser, new string[3] { "Function", "Gradient", "RegisteredGradients" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(FunctionDef), (MessageParser)(object)FunctionDef.Parser, new string[7] { "Signature", "Attr", "ArgAttr", "ResourceArgUniqueId", "NodeDef", "Ret", "ControlRet" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[6]
				{
					default(GeneratedClrTypeInfo),
					new GeneratedClrTypeInfo(typeof(FunctionDef.Types.ArgAttrs), (MessageParser)(object)FunctionDef.Types.ArgAttrs.Parser, new string[1] { "Attr" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
					default(GeneratedClrTypeInfo),
					default(GeneratedClrTypeInfo),
					default(GeneratedClrTypeInfo),
					default(GeneratedClrTypeInfo)
				}),
				new GeneratedClrTypeInfo(typeof(GradientDef), (MessageParser)(object)GradientDef.Parser, new string[2] { "FunctionName", "GradientFunc" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(RegisteredGradient), (MessageParser)(object)RegisteredGradient.Parser, new string[2] { "GradientFunc", "RegisteredOpType" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class FunctionDefLibrary : IMessage<FunctionDefLibrary>, IMessage, IEquatable<FunctionDefLibrary>, IDeepCloneable<FunctionDefLibrary>
	{
		private static readonly MessageParser<FunctionDefLibrary> _parser = new MessageParser<FunctionDefLibrary>((Func<FunctionDefLibrary>)(() => new FunctionDefLibrary()));

		private UnknownFieldSet _unknownFields;

		public const int FunctionFieldNumber = 1;

		private static readonly FieldCodec<FunctionDef> _repeated_function_codec = FieldCodec.ForMessage<FunctionDef>(10u, FunctionDef.Parser);

		private readonly RepeatedField<FunctionDef> function_ = new RepeatedField<FunctionDef>();

		public const int GradientFieldNumber = 2;

		private static readonly FieldCodec<GradientDef> _repeated_gradient_codec = FieldCodec.ForMessage<GradientDef>(18u, GradientDef.Parser);

		private readonly RepeatedField<GradientDef> gradient_ = new RepeatedField<GradientDef>();

		public const int RegisteredGradientsFieldNumber = 3;

		private static readonly FieldCodec<RegisteredGradient> _repeated_registeredGradients_codec = FieldCodec.ForMessage<RegisteredGradient>(26u, RegisteredGradient.Parser);

		private readonly RepeatedField<RegisteredGradient> registeredGradients_ = new RepeatedField<RegisteredGradient>();

		[DebuggerNonUserCode]
		public static MessageParser<FunctionDefLibrary> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => FunctionReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<FunctionDef> Function => function_;

		[DebuggerNonUserCode]
		public RepeatedField<GradientDef> Gradient => gradient_;

		[DebuggerNonUserCode]
		public RepeatedField<RegisteredGradient> RegisteredGradients => registeredGradients_;

		[DebuggerNonUserCode]
		public FunctionDefLibrary()
		{
		}

		[DebuggerNonUserCode]
		public FunctionDefLibrary(FunctionDefLibrary other)
			: this()
		{
			function_ = other.function_.Clone();
			gradient_ = other.gradient_.Clone();
			registeredGradients_ = other.registeredGradients_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public FunctionDefLibrary Clone()
		{
			return new FunctionDefLibrary(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as FunctionDefLibrary);
		}

		[DebuggerNonUserCode]
		public bool Equals(FunctionDefLibrary other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!function_.Equals(other.function_))
			{
				return false;
			}
			if (!gradient_.Equals(other.gradient_))
			{
				return false;
			}
			if (!registeredGradients_.Equals(other.registeredGradients_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)function_).GetHashCode();
			num ^= ((object)gradient_).GetHashCode();
			num ^= ((object)registeredGradients_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			function_.WriteTo(output, _repeated_function_codec);
			gradient_.WriteTo(output, _repeated_gradient_codec);
			registeredGradients_.WriteTo(output, _repeated_registeredGradients_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += function_.CalculateSize(_repeated_function_codec);
			num += gradient_.CalculateSize(_repeated_gradient_codec);
			num += registeredGradients_.CalculateSize(_repeated_registeredGradients_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(FunctionDefLibrary other)
		{
			if (other != null)
			{
				function_.Add((IEnumerable<FunctionDef>)other.function_);
				gradient_.Add((IEnumerable<GradientDef>)other.gradient_);
				registeredGradients_.Add((IEnumerable<RegisteredGradient>)other.registeredGradients_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					function_.AddEntriesFrom(input, _repeated_function_codec);
					break;
				case 18u:
					gradient_.AddEntriesFrom(input, _repeated_gradient_codec);
					break;
				case 26u:
					registeredGradients_.AddEntriesFrom(input, _repeated_registeredGradients_codec);
					break;
				}
			}
		}
	}
	public sealed class FunctionDef : IMessage<FunctionDef>, IMessage, IEquatable<FunctionDef>, IDeepCloneable<FunctionDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class ArgAttrs : IMessage<ArgAttrs>, IMessage, IEquatable<ArgAttrs>, IDeepCloneable<ArgAttrs>
			{
				private static readonly MessageParser<ArgAttrs> _parser = new MessageParser<ArgAttrs>((Func<ArgAttrs>)(() => new ArgAttrs()));

				private UnknownFieldSet _unknownFields;

				public const int AttrFieldNumber = 1;

				private static readonly Codec<string, AttrValue> _map_attr_codec = new Codec<string, AttrValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<AttrValue>(18u, AttrValue.Parser), 10u);

				private readonly MapField<string, AttrValue> attr_ = new MapField<string, AttrValue>();

				[DebuggerNonUserCode]
				public static MessageParser<ArgAttrs> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => FunctionDef.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public MapField<string, AttrValue> Attr => attr_;

				[DebuggerNonUserCode]
				public ArgAttrs()
				{
				}

				[DebuggerNonUserCode]
				public ArgAttrs(ArgAttrs other)
					: this()
				{
					attr_ = other.attr_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public ArgAttrs Clone()
				{
					return new ArgAttrs(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as ArgAttrs);
				}

				[DebuggerNonUserCode]
				public bool Equals(ArgAttrs other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!Attr.Equals(other.Attr))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)Attr).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					attr_.WriteTo(output, _map_attr_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += attr_.CalculateSize(_map_attr_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(ArgAttrs other)
				{
					if (other != null)
					{
						attr_.Add((IDictionary<string, AttrValue>)other.attr_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						if (num != 10)
						{
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
						}
						else
						{
							attr_.AddEntriesFrom(input, _map_attr_codec);
						}
					}
				}
			}
		}

		private static readonly MessageParser<FunctionDef> _parser = new MessageParser<FunctionDef>((Func<FunctionDef>)(() => new FunctionDef()));

		private UnknownFieldSet _unknownFields;

		public const int SignatureFieldNumber = 1;

		private OpDef signature_;

		public const int AttrFieldNumber = 5;

		private static readonly Codec<string, AttrValue> _map_attr_codec = new Codec<string, AttrValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<AttrValue>(18u, AttrValue.Parser), 42u);

		private readonly MapField<string, AttrValue> attr_ = new MapField<string, AttrValue>();

		public const int ArgAttrFieldNumber = 7;

		private static readonly Codec<uint, Types.ArgAttrs> _map_argAttr_codec = new Codec<uint, Types.ArgAttrs>(FieldCodec.ForUInt32(8u, 0u), FieldCodec.ForMessage<Types.ArgAttrs>(18u, Types.ArgAttrs.Parser), 58u);

		private readonly MapField<uint, Types.ArgAttrs> argAttr_ = new MapField<uint, Types.ArgAttrs>();

		public const int ResourceArgUniqueIdFieldNumber = 8;

		private static readonly Codec<uint, uint> _map_resourceArgUniqueId_codec = new Codec<uint, uint>(FieldCodec.ForUInt32(8u, 0u), FieldCodec.ForUInt32(16u, 0u), 66u);

		private readonly MapField<uint, uint> resourceArgUniqueId_ = new MapField<uint, uint>();

		public const int NodeDefFieldNumber = 3;

		private static readonly FieldCodec<NodeDef> _repeated_nodeDef_codec = FieldCodec.ForMessage<NodeDef>(26u, Tensorboard.NodeDef.Parser);

		private readonly RepeatedField<NodeDef> nodeDef_ = new RepeatedField<NodeDef>();

		public const int RetFieldNumber = 4;

		private static readonly Codec<string, string> _map_ret_codec = new Codec<string, string>(FieldCodec.ForString(10u, ""), FieldCodec.ForString(18u, ""), 34u);

		private readonly MapField<string, string> ret_ = new MapField<string, string>();

		public const int ControlRetFieldNumber = 6;

		private static readonly Codec<string, string> _map_controlRet_codec = new Codec<string, string>(FieldCodec.ForString(10u, ""), FieldCodec.ForString(18u, ""), 50u);

		private readonly MapField<string, string> controlRet_ = new MapField<string, string>();

		[DebuggerNonUserCode]
		public static MessageParser<FunctionDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => FunctionReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public OpDef Signature
		{
			get
			{
				return signature_;
			}
			set
			{
				signature_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, AttrValue> Attr => attr_;

		[DebuggerNonUserCode]
		public MapField<uint, Types.ArgAttrs> ArgAttr => argAttr_;

		[DebuggerNonUserCode]
		public MapField<uint, uint> ResourceArgUniqueId => resourceArgUniqueId_;

		[DebuggerNonUserCode]
		public RepeatedField<NodeDef> NodeDef => nodeDef_;

		[DebuggerNonUserCode]
		public MapField<string, string> Ret => ret_;

		[DebuggerNonUserCode]
		public MapField<string, string> ControlRet => controlRet_;

		[DebuggerNonUserCode]
		public FunctionDef()
		{
		}

		[DebuggerNonUserCode]
		public FunctionDef(FunctionDef other)
			: this()
		{
			signature_ = ((other.signature_ != null) ? other.signature_.Clone() : null);
			attr_ = other.attr_.Clone();
			argAttr_ = other.argAttr_.Clone();
			resourceArgUniqueId_ = other.resourceArgUniqueId_.Clone();
			nodeDef_ = other.nodeDef_.Clone();
			ret_ = other.ret_.Clone();
			controlRet_ = other.controlRet_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public FunctionDef Clone()
		{
			return new FunctionDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as FunctionDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(FunctionDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(Signature, other.Signature))
			{
				return false;
			}
			if (!Attr.Equals(other.Attr))
			{
				return false;
			}
			if (!ArgAttr.Equals(other.ArgAttr))
			{
				return false;
			}
			if (!ResourceArgUniqueId.Equals(other.ResourceArgUniqueId))
			{
				return false;
			}
			if (!nodeDef_.Equals(other.nodeDef_))
			{
				return false;
			}
			if (!Ret.Equals(other.Ret))
			{
				return false;
			}
			if (!ControlRet.Equals(other.ControlRet))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (signature_ != null)
			{
				num ^= Signature.GetHashCode();
			}
			num ^= ((object)Attr).GetHashCode();
			num ^= ((object)ArgAttr).GetHashCode();
			num ^= ((object)ResourceArgUniqueId).GetHashCode();
			num ^= ((object)nodeDef_).GetHashCode();
			num ^= ((object)Ret).GetHashCode();
			num ^= ((object)ControlRet).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (signature_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)Signature);
			}
			nodeDef_.WriteTo(output, _repeated_nodeDef_codec);
			ret_.WriteTo(output, _map_ret_codec);
			attr_.WriteTo(output, _map_attr_codec);
			controlRet_.WriteTo(output, _map_controlRet_codec);
			argAttr_.WriteTo(output, _map_argAttr_codec);
			resourceArgUniqueId_.WriteTo(output, _map_resourceArgUniqueId_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (signature_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Signature);
			}
			num += attr_.CalculateSize(_map_attr_codec);
			num += argAttr_.CalculateSize(_map_argAttr_codec);
			num += resourceArgUniqueId_.CalculateSize(_map_resourceArgUniqueId_codec);
			num += nodeDef_.CalculateSize(_repeated_nodeDef_codec);
			num += ret_.CalculateSize(_map_ret_codec);
			num += controlRet_.CalculateSize(_map_controlRet_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(FunctionDef other)
		{
			if (other == null)
			{
				return;
			}
			if (other.signature_ != null)
			{
				if (signature_ == null)
				{
					Signature = new OpDef();
				}
				Signature.MergeFrom(other.Signature);
			}
			attr_.Add((IDictionary<string, AttrValue>)other.attr_);
			argAttr_.Add((IDictionary<uint, Types.ArgAttrs>)other.argAttr_);
			resourceArgUniqueId_.Add((IDictionary<uint, uint>)other.resourceArgUniqueId_);
			nodeDef_.Add((IEnumerable<NodeDef>)other.nodeDef_);
			ret_.Add((IDictionary<string, string>)other.ret_);
			controlRet_.Add((IDictionary<string, string>)other.controlRet_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (signature_ == null)
					{
						Signature = new OpDef();
					}
					input.ReadMessage((IMessage)(object)Signature);
					break;
				case 26u:
					nodeDef_.AddEntriesFrom(input, _repeated_nodeDef_codec);
					break;
				case 34u:
					ret_.AddEntriesFrom(input, _map_ret_codec);
					break;
				case 42u:
					attr_.AddEntriesFrom(input, _map_attr_codec);
					break;
				case 50u:
					controlRet_.AddEntriesFrom(input, _map_controlRet_codec);
					break;
				case 58u:
					argAttr_.AddEntriesFrom(input, _map_argAttr_codec);
					break;
				case 66u:
					resourceArgUniqueId_.AddEntriesFrom(input, _map_resourceArgUniqueId_codec);
					break;
				}
			}
		}
	}
	public sealed class GradientDef : IMessage<GradientDef>, IMessage, IEquatable<GradientDef>, IDeepCloneable<GradientDef>
	{
		private static readonly MessageParser<GradientDef> _parser = new MessageParser<GradientDef>((Func<GradientDef>)(() => new GradientDef()));

		private UnknownFieldSet _unknownFields;

		public const int FunctionNameFieldNumber = 1;

		private string functionName_ = "";

		public const int GradientFuncFieldNumber = 2;

		private string gradientFunc_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<GradientDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => FunctionReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string FunctionName
		{
			get
			{
				return functionName_;
			}
			set
			{
				functionName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string GradientFunc
		{
			get
			{
				return gradientFunc_;
			}
			set
			{
				gradientFunc_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public GradientDef()
		{
		}

		[DebuggerNonUserCode]
		public GradientDef(GradientDef other)
			: this()
		{
			functionName_ = other.functionName_;
			gradientFunc_ = other.gradientFunc_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public GradientDef Clone()
		{
			return new GradientDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as GradientDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(GradientDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (FunctionName != other.FunctionName)
			{
				return false;
			}
			if (GradientFunc != other.GradientFunc)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (FunctionName.Length != 0)
			{
				num ^= FunctionName.GetHashCode();
			}
			if (GradientFunc.Length != 0)
			{
				num ^= GradientFunc.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (FunctionName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(FunctionName);
			}
			if (GradientFunc.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(GradientFunc);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (FunctionName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FunctionName);
			}
			if (GradientFunc.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(GradientFunc);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(GradientDef other)
		{
			if (other != null)
			{
				if (other.FunctionName.Length != 0)
				{
					FunctionName = other.FunctionName;
				}
				if (other.GradientFunc.Length != 0)
				{
					GradientFunc = other.GradientFunc;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					FunctionName = input.ReadString();
					break;
				case 18u:
					GradientFunc = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class RegisteredGradient : IMessage<RegisteredGradient>, IMessage, IEquatable<RegisteredGradient>, IDeepCloneable<RegisteredGradient>
	{
		private static readonly MessageParser<RegisteredGradient> _parser = new MessageParser<RegisteredGradient>((Func<RegisteredGradient>)(() => new RegisteredGradient()));

		private UnknownFieldSet _unknownFields;

		public const int GradientFuncFieldNumber = 1;

		private string gradientFunc_ = "";

		public const int RegisteredOpTypeFieldNumber = 2;

		private string registeredOpType_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<RegisteredGradient> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => FunctionReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string GradientFunc
		{
			get
			{
				return gradientFunc_;
			}
			set
			{
				gradientFunc_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string RegisteredOpType
		{
			get
			{
				return registeredOpType_;
			}
			set
			{
				registeredOpType_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RegisteredGradient()
		{
		}

		[DebuggerNonUserCode]
		public RegisteredGradient(RegisteredGradient other)
			: this()
		{
			gradientFunc_ = other.gradientFunc_;
			registeredOpType_ = other.registeredOpType_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RegisteredGradient Clone()
		{
			return new RegisteredGradient(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RegisteredGradient);
		}

		[DebuggerNonUserCode]
		public bool Equals(RegisteredGradient other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (GradientFunc != other.GradientFunc)
			{
				return false;
			}
			if (RegisteredOpType != other.RegisteredOpType)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (GradientFunc.Length != 0)
			{
				num ^= GradientFunc.GetHashCode();
			}
			if (RegisteredOpType.Length != 0)
			{
				num ^= RegisteredOpType.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (GradientFunc.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(GradientFunc);
			}
			if (RegisteredOpType.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(RegisteredOpType);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (GradientFunc.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(GradientFunc);
			}
			if (RegisteredOpType.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(RegisteredOpType);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RegisteredGradient other)
		{
			if (other != null)
			{
				if (other.GradientFunc.Length != 0)
				{
					GradientFunc = other.GradientFunc;
				}
				if (other.RegisteredOpType.Length != 0)
				{
					RegisteredOpType = other.RegisteredOpType;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					GradientFunc = input.ReadString();
					break;
				case 18u:
					RegisteredOpType = input.ReadString();
					break;
				}
			}
		}
	}
	public static class GraphReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static GraphReflection()
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiR0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vZ3JhcGgucHJvdG8SC3RlbnNv" + "cmJvYXJkGid0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vZnVuY3Rpb24ucHJv" + "dG8aJ3RlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9ub2RlX2RlZi5wcm90bxon" + "dGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3ZlcnNpb25zLnByb3RvIqABCghH" + "cmFwaERlZhIiCgRub2RlGAEgAygLMhQudGVuc29yYm9hcmQuTm9kZURlZhIp" + "Cgh2ZXJzaW9ucxgEIAEoCzIXLnRlbnNvcmJvYXJkLlZlcnNpb25EZWYSEwoH" + "dmVyc2lvbhgDIAEoBUICGAESMAoHbGlicmFyeRgCIAEoCzIfLnRlbnNvcmJv" + "YXJkLkZ1bmN0aW9uRGVmTGlicmFyeUJ6ChhvcmcudGVuc29yZmxvdy5mcmFt" + "ZXdvcmtCC0dyYXBoUHJvdG9zUAFaTGdpdGh1Yi5jb20vdGVuc29yZmxvdy90" + "ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28vY29yZS9mcmFtZXdvcmsvZ3JhcGhf" + "Z29fcHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				FunctionReflection.Descriptor,
				NodeDefReflection.Descriptor,
				VersionsReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(GraphDef), (MessageParser)(object)GraphDef.Parser, new string[4] { "Node", "Versions", "Version", "Library" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class GraphDef : IMessage<GraphDef>, IMessage, IEquatable<GraphDef>, IDeepCloneable<GraphDef>
	{
		private static readonly MessageParser<GraphDef> _parser = new MessageParser<GraphDef>((Func<GraphDef>)(() => new GraphDef()));

		private UnknownFieldSet _unknownFields;

		public const int NodeFieldNumber = 1;

		private static readonly FieldCodec<NodeDef> _repeated_node_codec = FieldCodec.ForMessage<NodeDef>(10u, NodeDef.Parser);

		private readonly RepeatedField<NodeDef> node_ = new RepeatedField<NodeDef>();

		public const int VersionsFieldNumber = 4;

		private VersionDef versions_;

		public const int VersionFieldNumber = 3;

		private int version_;

		public const int LibraryFieldNumber = 2;

		private FunctionDefLibrary library_;

		[DebuggerNonUserCode]
		public static MessageParser<GraphDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => GraphReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<NodeDef> Node => node_;

		[DebuggerNonUserCode]
		public VersionDef Versions
		{
			get
			{
				return versions_;
			}
			set
			{
				versions_ = value;
			}
		}

		[Obsolete]
		[DebuggerNonUserCode]
		public int Version
		{
			get
			{
				return version_;
			}
			set
			{
				version_ = value;
			}
		}

		[DebuggerNonUserCode]
		public FunctionDefLibrary Library
		{
			get
			{
				return library_;
			}
			set
			{
				library_ = value;
			}
		}

		[DebuggerNonUserCode]
		public GraphDef()
		{
		}

		[DebuggerNonUserCode]
		public GraphDef(GraphDef other)
			: this()
		{
			node_ = other.node_.Clone();
			versions_ = ((other.versions_ != null) ? other.versions_.Clone() : null);
			version_ = other.version_;
			library_ = ((other.library_ != null) ? other.library_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public GraphDef Clone()
		{
			return new GraphDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as GraphDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(GraphDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!node_.Equals(other.node_))
			{
				return false;
			}
			if (!object.Equals(Versions, other.Versions))
			{
				return false;
			}
			if (Version != other.Version)
			{
				return false;
			}
			if (!object.Equals(Library, other.Library))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)node_).GetHashCode();
			if (versions_ != null)
			{
				num ^= Versions.GetHashCode();
			}
			if (Version != 0)
			{
				num ^= Version.GetHashCode();
			}
			if (library_ != null)
			{
				num ^= Library.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			node_.WriteTo(output, _repeated_node_codec);
			if (library_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Library);
			}
			if (Version != 0)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt32(Version);
			}
			if (versions_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)Versions);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += node_.CalculateSize(_repeated_node_codec);
			if (versions_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Versions);
			}
			if (Version != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Version);
			}
			if (library_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Library);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(GraphDef other)
		{
			if (other == null)
			{
				return;
			}
			node_.Add((IEnumerable<NodeDef>)other.node_);
			if (other.versions_ != null)
			{
				if (versions_ == null)
				{
					Versions = new VersionDef();
				}
				Versions.MergeFrom(other.Versions);
			}
			if (other.Version != 0)
			{
				Version = other.Version;
			}
			if (other.library_ != null)
			{
				if (library_ == null)
				{
					Library = new FunctionDefLibrary();
				}
				Library.MergeFrom(other.Library);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					node_.AddEntriesFrom(input, _repeated_node_codec);
					break;
				case 18u:
					if (library_ == null)
					{
						Library = new FunctionDefLibrary();
					}
					input.ReadMessage((IMessage)(object)Library);
					break;
				case 24u:
					Version = input.ReadInt32();
					break;
				case 34u:
					if (versions_ == null)
					{
						Versions = new VersionDef();
					}
					input.ReadMessage((IMessage)(object)Versions);
					break;
				}
			}
		}
	}
	public static class MetaGraphReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static MetaGraphReflection()
		{
			//IL_0345: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Expected O, but got Unknown
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Expected O, but got Unknown
			//IL_03c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03cf: Expected O, but got Unknown
			//IL_03f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f8: Expected O, but got Unknown
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0421: Expected O, but got Unknown
			//IL_0444: Unknown result type (might be due to invalid IL or missing references)
			//IL_044a: Expected O, but got Unknown
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0473: Expected O, but got Unknown
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Expected O, but got Unknown
			//IL_0501: Unknown result type (might be due to invalid IL or missing references)
			//IL_0507: Expected O, but got Unknown
			//IL_0532: Unknown result type (might be due to invalid IL or missing references)
			//IL_0538: Expected O, but got Unknown
			//IL_0538: Unknown result type (might be due to invalid IL or missing references)
			//IL_053e: Expected O, but got Unknown
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_057c: Expected O, but got Unknown
			//IL_05a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Expected O, but got Unknown
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vbWV0YV9ncmFwaC5wcm90bxIL" + "dGVuc29yYm9hcmQaGWdvb2dsZS9wcm90b2J1Zi9hbnkucHJvdG8aJHRlbnNv" + "cmJvYXJkL2NvbXBhdC9wcm90by9ncmFwaC5wcm90bxoldGVuc29yYm9hcmQv" + "Y29tcGF0L3Byb3RvL29wX2RlZi5wcm90bxordGVuc29yYm9hcmQvY29tcGF0" + "L3Byb3RvL3RlbnNvcl9zaGFwZS5wcm90bxokdGVuc29yYm9hcmQvY29tcGF0" + "L3Byb3RvL3R5cGVzLnByb3RvGjF0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8v" + "c2F2ZWRfb2JqZWN0X2dyYXBoLnByb3RvGiR0ZW5zb3Jib2FyZC9jb21wYXQv" + "cHJvdG8vc2F2ZXIucHJvdG8aJXRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9z" + "dHJ1Y3QucHJvdG8iswcKDE1ldGFHcmFwaERlZhI8Cg1tZXRhX2luZm9fZGVm" + "GAEgASgLMiUudGVuc29yYm9hcmQuTWV0YUdyYXBoRGVmLk1ldGFJbmZvRGVm" + "EigKCWdyYXBoX2RlZhgCIAEoCzIVLnRlbnNvcmJvYXJkLkdyYXBoRGVmEigK" + "CXNhdmVyX2RlZhgDIAEoCzIVLnRlbnNvcmJvYXJkLlNhdmVyRGVmEkQKDmNv" + "bGxlY3Rpb25fZGVmGAQgAygLMiwudGVuc29yYm9hcmQuTWV0YUdyYXBoRGVm" + "LkNvbGxlY3Rpb25EZWZFbnRyeRJCCg1zaWduYXR1cmVfZGVmGAUgAygLMisu" + "dGVuc29yYm9hcmQuTWV0YUdyYXBoRGVmLlNpZ25hdHVyZURlZkVudHJ5EjEK" + "DmFzc2V0X2ZpbGVfZGVmGAYgAygLMhkudGVuc29yYm9hcmQuQXNzZXRGaWxl" + "RGVmEjcKEG9iamVjdF9ncmFwaF9kZWYYByABKAsyHS50ZW5zb3Jib2FyZC5T" + "YXZlZE9iamVjdEdyYXBoGvgCCgtNZXRhSW5mb0RlZhIaChJtZXRhX2dyYXBo" + "X3ZlcnNpb24YASABKAkSLQoQc3RyaXBwZWRfb3BfbGlzdBgCIAEoCzITLnRl" + "bnNvcmJvYXJkLk9wTGlzdBImCghhbnlfaW5mbxgDIAEoCzIULmdvb2dsZS5w" + "cm90b2J1Zi5BbnkSDAoEdGFncxgEIAMoCRIaChJ0ZW5zb3JmbG93X3ZlcnNp" + "b24YBSABKAkSHgoWdGVuc29yZmxvd19naXRfdmVyc2lvbhgGIAEoCRIeChZz" + "dHJpcHBlZF9kZWZhdWx0X2F0dHJzGAcgASgIElQKEGZ1bmN0aW9uX2FsaWFz" + "ZXMYCCADKAsyOi50ZW5zb3Jib2FyZC5NZXRhR3JhcGhEZWYuTWV0YUluZm9E" + "ZWYuRnVuY3Rpb25BbGlhc2VzRW50cnkaNgoURnVuY3Rpb25BbGlhc2VzRW50" + "cnkSCwoDa2V5GAEgASgJEg0KBXZhbHVlGAIgASgJOgI4ARpQChJDb2xsZWN0" + "aW9uRGVmRW50cnkSCwoDa2V5GAEgASgJEikKBXZhbHVlGAIgASgLMhoudGVu" + "c29yYm9hcmQuQ29sbGVjdGlvbkRlZjoCOAEaTgoRU2lnbmF0dXJlRGVmRW50" + "cnkSCwoDa2V5GAEgASgJEigKBXZhbHVlGAIgASgLMhkudGVuc29yYm9hcmQu" + "U2lnbmF0dXJlRGVmOgI4ASLkAwoNQ29sbGVjdGlvbkRlZhI4Cglub2RlX2xp" + "c3QYASABKAsyIy50ZW5zb3Jib2FyZC5Db2xsZWN0aW9uRGVmLk5vZGVMaXN0" + "SAASOgoKYnl0ZXNfbGlzdBgCIAEoCzIkLnRlbnNvcmJvYXJkLkNvbGxlY3Rp" + "b25EZWYuQnl0ZXNMaXN0SAASOgoKaW50NjRfbGlzdBgDIAEoCzIkLnRlbnNv" + "cmJvYXJkLkNvbGxlY3Rpb25EZWYuSW50NjRMaXN0SAASOgoKZmxvYXRfbGlz" + "dBgEIAEoCzIkLnRlbnNvcmJvYXJkLkNvbGxlY3Rpb25EZWYuRmxvYXRMaXN0" + "SAASNgoIYW55X2xpc3QYBSABKAsyIi50ZW5zb3Jib2FyZC5Db2xsZWN0aW9u" + "RGVmLkFueUxpc3RIABoZCghOb2RlTGlzdBINCgV2YWx1ZRgBIAMoCRoaCglC" + "eXRlc0xpc3QSDQoFdmFsdWUYASADKAwaHgoJSW50NjRMaXN0EhEKBXZhbHVl" + "GAEgAygDQgIQARoeCglGbG9hdExpc3QSEQoFdmFsdWUYASADKAJCAhABGi4K" + "B0FueUxpc3QSIwoFdmFsdWUYASADKAsyFC5nb29nbGUucHJvdG9idWYuQW55" + "QgYKBGtpbmQi1wMKClRlbnNvckluZm8SDgoEbmFtZRgBIAEoCUgAEjcKCmNv" + "b19zcGFyc2UYBCABKAsyIS50ZW5zb3Jib2FyZC5UZW5zb3JJbmZvLkNvb1Nw" + "YXJzZUgAEkMKEGNvbXBvc2l0ZV90ZW5zb3IYBSABKAsyJy50ZW5zb3Jib2Fy" + "ZC5UZW5zb3JJbmZvLkNvbXBvc2l0ZVRlbnNvckgAEiQKBWR0eXBlGAIgASgO" + "MhUudGVuc29yYm9hcmQuRGF0YVR5cGUSMwoMdGVuc29yX3NoYXBlGAMgASgL" + "Mh0udGVuc29yYm9hcmQuVGVuc29yU2hhcGVQcm90bxplCglDb29TcGFyc2US" + "GgoSdmFsdWVzX3RlbnNvcl9uYW1lGAEgASgJEhsKE2luZGljZXNfdGVuc29y" + "X25hbWUYAiABKAkSHwoXZGVuc2Vfc2hhcGVfdGVuc29yX25hbWUYAyABKAka" + "bQoPQ29tcG9zaXRlVGVuc29yEi0KCXR5cGVfc3BlYxgBIAEoCzIaLnRlbnNv" + "cmJvYXJkLlR5cGVTcGVjUHJvdG8SKwoKY29tcG9uZW50cxgCIAMoCzIXLnRl" + "bnNvcmJvYXJkLlRlbnNvckluZm9CCgoIZW5jb2RpbmcipAIKDFNpZ25hdHVy" + "ZURlZhI1CgZpbnB1dHMYASADKAsyJS50ZW5zb3Jib2FyZC5TaWduYXR1cmVE" + "ZWYuSW5wdXRzRW50cnkSNwoHb3V0cHV0cxgCIAMoCzImLnRlbnNvcmJvYXJk" + "LlNpZ25hdHVyZURlZi5PdXRwdXRzRW50cnkSEwoLbWV0aG9kX25hbWUYAyAB" + "KAkaRgoLSW5wdXRzRW50cnkSCwoDa2V5GAEgASgJEiYKBXZhbHVlGAIgASgL" + "MhcudGVuc29yYm9hcmQuVGVuc29ySW5mbzoCOAEaRwoMT3V0cHV0c0VudHJ5" + "EgsKA2tleRgBIAEoCRImCgV2YWx1ZRgCIAEoCzIXLnRlbnNvcmJvYXJkLlRl" + "bnNvckluZm86AjgBIk4KDEFzc2V0RmlsZURlZhIsCgt0ZW5zb3JfaW5mbxgB" + "IAEoCzIXLnRlbnNvcmJvYXJkLlRlbnNvckluZm8SEAoIZmlsZW5hbWUYAiAB" + "KAlChwEKGG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0IPTWV0YUdyYXBoUHJv" + "dG9zUAFaVWdpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNv" + "cmZsb3cvZ28vY29yZS9wcm90b2J1Zi9mb3JfY29yZV9wcm90b3NfZ29fcHJv" + "dG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[8]
			{
				AnyReflection.Descriptor,
				GraphReflection.Descriptor,
				OpDefReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor,
				SavedObjectGraphReflection.Descriptor,
				SaverReflection.Descriptor,
				StructReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[5]
			{
				new GeneratedClrTypeInfo(typeof(MetaGraphDef), (MessageParser)(object)MetaGraphDef.Parser, new string[7] { "MetaInfoDef", "GraphDef", "SaverDef", "CollectionDef", "SignatureDef", "AssetFileDef", "ObjectGraphDef" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[3]
				{
					new GeneratedClrTypeInfo(typeof(MetaGraphDef.Types.MetaInfoDef), (MessageParser)(object)MetaGraphDef.Types.MetaInfoDef.Parser, new string[8] { "MetaGraphVersion", "StrippedOpList", "AnyInfo", "Tags", "TensorflowVersion", "TensorflowGitVersion", "StrippedDefaultAttrs", "FunctionAliases" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
					default(GeneratedClrTypeInfo),
					default(GeneratedClrTypeInfo)
				}),
				new GeneratedClrTypeInfo(typeof(CollectionDef), (MessageParser)(object)CollectionDef.Parser, new string[5] { "NodeList", "BytesList", "Int64List", "FloatList", "AnyList" }, new string[1] { "Kind" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[5]
				{
					new GeneratedClrTypeInfo(typeof(CollectionDef.Types.NodeList), (MessageParser)(object)CollectionDef.Types.NodeList.Parser, new string[1] { "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(CollectionDef.Types.BytesList), (MessageParser)(object)CollectionDef.Types.BytesList.Parser, new string[1] { "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(CollectionDef.Types.Int64List), (MessageParser)(object)CollectionDef.Types.Int64List.Parser, new string[1] { "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(CollectionDef.Types.FloatList), (MessageParser)(object)CollectionDef.Types.FloatList.Parser, new string[1] { "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(CollectionDef.Types.AnyList), (MessageParser)(object)CollectionDef.Types.AnyList.Parser, new string[1] { "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(TensorInfo), (MessageParser)(object)TensorInfo.Parser, new string[5] { "Name", "CooSparse", "CompositeTensor", "Dtype", "TensorShape" }, new string[1] { "Encoding" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
				{
					new GeneratedClrTypeInfo(typeof(TensorInfo.Types.CooSparse), (MessageParser)(object)TensorInfo.Types.CooSparse.Parser, new string[3] { "ValuesTensorName", "IndicesTensorName", "DenseShapeTensorName" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(TensorInfo.Types.CompositeTensor), (MessageParser)(object)TensorInfo.Types.CompositeTensor.Parser, new string[2] { "TypeSpec", "Components" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(SignatureDef), (MessageParser)(object)SignatureDef.Parser, new string[3] { "Inputs", "Outputs", "MethodName" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]),
				new GeneratedClrTypeInfo(typeof(AssetFileDef), (MessageParser)(object)AssetFileDef.Parser, new string[2] { "TensorInfo", "Filename" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class MetaGraphDef : IMessage<MetaGraphDef>, IMessage, IEquatable<MetaGraphDef>, IDeepCloneable<MetaGraphDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class MetaInfoDef : IMessage<MetaInfoDef>, IMessage, IEquatable<MetaInfoDef>, IDeepCloneable<MetaInfoDef>
			{
				private static readonly MessageParser<MetaInfoDef> _parser = new MessageParser<MetaInfoDef>((Func<MetaInfoDef>)(() => new MetaInfoDef()));

				private UnknownFieldSet _unknownFields;

				public const int MetaGraphVersionFieldNumber = 1;

				private string metaGraphVersion_ = "";

				public const int StrippedOpListFieldNumber = 2;

				private OpList strippedOpList_;

				public const int AnyInfoFieldNumber = 3;

				private Any anyInfo_;

				public const int TagsFieldNumber = 4;

				private static readonly FieldCodec<string> _repeated_tags_codec = FieldCodec.ForString(34u);

				private readonly RepeatedField<string> tags_ = new RepeatedField<string>();

				public const int TensorflowVersionFieldNumber = 5;

				private string tensorflowVersion_ = "";

				public const int TensorflowGitVersionFieldNumber = 6;

				private string tensorflowGitVersion_ = "";

				public const int StrippedDefaultAttrsFieldNumber = 7;

				private bool strippedDefaultAttrs_;

				public const int FunctionAliasesFieldNumber = 8;

				private static readonly Codec<string, string> _map_functionAliases_codec = new Codec<string, string>(FieldCodec.ForString(10u, ""), FieldCodec.ForString(18u, ""), 66u);

				private readonly MapField<string, string> functionAliases_ = new MapField<string, string>();

				[DebuggerNonUserCode]
				public static MessageParser<MetaInfoDef> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => MetaGraphDef.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string MetaGraphVersion
				{
					get
					{
						return metaGraphVersion_;
					}
					set
					{
						metaGraphVersion_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public OpList StrippedOpList
				{
					get
					{
						return strippedOpList_;
					}
					set
					{
						strippedOpList_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Any AnyInfo
				{
					get
					{
						return anyInfo_;
					}
					set
					{
						anyInfo_ = value;
					}
				}

				[DebuggerNonUserCode]
				public RepeatedField<string> Tags => tags_;

				[DebuggerNonUserCode]
				public string TensorflowVersion
				{
					get
					{
						return tensorflowVersion_;
					}
					set
					{
						tensorflowVersion_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string TensorflowGitVersion
				{
					get
					{
						return tensorflowGitVersion_;
					}
					set
					{
						tensorflowGitVersion_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public bool StrippedDefaultAttrs
				{
					get
					{
						return strippedDefaultAttrs_;
					}
					set
					{
						strippedDefaultAttrs_ = value;
					}
				}

				[DebuggerNonUserCode]
				public MapField<string, string> FunctionAliases => functionAliases_;

				[DebuggerNonUserCode]
				public MetaInfoDef()
				{
				}

				[DebuggerNonUserCode]
				public MetaInfoDef(MetaInfoDef other)
					: this()
				{
					metaGraphVersion_ = other.metaGraphVersion_;
					strippedOpList_ = ((other.strippedOpList_ != null) ? other.strippedOpList_.Clone() : null);
					anyInfo_ = ((other.anyInfo_ != null) ? other.anyInfo_.Clone() : null);
					tags_ = other.tags_.Clone();
					tensorflowVersion_ = other.tensorflowVersion_;
					tensorflowGitVersion_ = other.tensorflowGitVersion_;
					strippedDefaultAttrs_ = other.strippedDefaultAttrs_;
					functionAliases_ = other.functionAliases_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public MetaInfoDef Clone()
				{
					return new MetaInfoDef(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as MetaInfoDef);
				}

				[DebuggerNonUserCode]
				public bool Equals(MetaInfoDef other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (MetaGraphVersion != other.MetaGraphVersion)
					{
						return false;
					}
					if (!object.Equals(StrippedOpList, other.StrippedOpList))
					{
						return false;
					}
					if (!object.Equals(AnyInfo, other.AnyInfo))
					{
						return false;
					}
					if (!tags_.Equals(other.tags_))
					{
						return false;
					}
					if (TensorflowVersion != other.TensorflowVersion)
					{
						return false;
					}
					if (TensorflowGitVersion != other.TensorflowGitVersion)
					{
						return false;
					}
					if (StrippedDefaultAttrs != other.StrippedDefaultAttrs)
					{
						return false;
					}
					if (!FunctionAliases.Equals(other.FunctionAliases))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (MetaGraphVersion.Length != 0)
					{
						num ^= MetaGraphVersion.GetHashCode();
					}
					if (strippedOpList_ != null)
					{
						num ^= StrippedOpList.GetHashCode();
					}
					if (anyInfo_ != null)
					{
						num ^= ((object)AnyInfo).GetHashCode();
					}
					num ^= ((object)tags_).GetHashCode();
					if (TensorflowVersion.Length != 0)
					{
						num ^= TensorflowVersion.GetHashCode();
					}
					if (TensorflowGitVersion.Length != 0)
					{
						num ^= TensorflowGitVersion.GetHashCode();
					}
					if (StrippedDefaultAttrs)
					{
						num ^= StrippedDefaultAttrs.GetHashCode();
					}
					num ^= ((object)FunctionAliases).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (MetaGraphVersion.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(MetaGraphVersion);
					}
					if (strippedOpList_ != null)
					{
						output.WriteRawTag((byte)18);
						output.WriteMessage((IMessage)(object)StrippedOpList);
					}
					if (anyInfo_ != null)
					{
						output.WriteRawTag((byte)26);
						output.WriteMessage((IMessage)(object)AnyInfo);
					}
					tags_.WriteTo(output, _repeated_tags_codec);
					if (TensorflowVersion.Length != 0)
					{
						output.WriteRawTag((byte)42);
						output.WriteString(TensorflowVersion);
					}
					if (TensorflowGitVersion.Length != 0)
					{
						output.WriteRawTag((byte)50);
						output.WriteString(TensorflowGitVersion);
					}
					if (StrippedDefaultAttrs)
					{
						output.WriteRawTag((byte)56);
						output.WriteBool(StrippedDefaultAttrs);
					}
					functionAliases_.WriteTo(output, _map_functionAliases_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (MetaGraphVersion.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(MetaGraphVersion);
					}
					if (strippedOpList_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)StrippedOpList);
					}
					if (anyInfo_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)AnyInfo);
					}
					num += tags_.CalculateSize(_repeated_tags_codec);
					if (TensorflowVersion.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(TensorflowVersion);
					}
					if (TensorflowGitVersion.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(TensorflowGitVersion);
					}
					if (StrippedDefaultAttrs)
					{
						num += 2;
					}
					num += functionAliases_.CalculateSize(_map_functionAliases_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(MetaInfoDef other)
				{
					//IL_005a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0064: Expected O, but got Unknown
					if (other == null)
					{
						return;
					}
					if (other.MetaGraphVersion.Length != 0)
					{
						MetaGraphVersion = other.MetaGraphVersion;
					}
					if (other.strippedOpList_ != null)
					{
						if (strippedOpList_ == null)
						{
							StrippedOpList = new OpList();
						}
						StrippedOpList.MergeFrom(other.StrippedOpList);
					}
					if (other.anyInfo_ != null)
					{
						if (anyInfo_ == null)
						{
							AnyInfo = new Any();
						}
						AnyInfo.MergeFrom(other.AnyInfo);
					}
					tags_.Add((IEnumerable<string>)other.tags_);
					if (other.TensorflowVersion.Length != 0)
					{
						TensorflowVersion = other.TensorflowVersion;
					}
					if (other.TensorflowGitVersion.Length != 0)
					{
						TensorflowGitVersion = other.TensorflowGitVersion;
					}
					if (other.StrippedDefaultAttrs)
					{
						StrippedDefaultAttrs = other.StrippedDefaultAttrs;
					}
					functionAliases_.Add((IDictionary<string, string>)other.functionAliases_);
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ad: Expected O, but got Unknown
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							MetaGraphVersion = input.ReadString();
							break;
						case 18u:
							if (strippedOpList_ == null)
							{
								StrippedOpList = new OpList();
							}
							input.ReadMessage((IMessage)(object)StrippedOpList);
							break;
						case 26u:
							if (anyInfo_ == null)
							{
								AnyInfo = new Any();
							}
							input.ReadMessage((IMessage)(object)AnyInfo);
							break;
						case 34u:
							tags_.AddEntriesFrom(input, _repeated_tags_codec);
							break;
						case 42u:
							TensorflowVersion = input.ReadString();
							break;
						case 50u:
							TensorflowGitVersion = input.ReadString();
							break;
						case 56u:
							StrippedDefaultAttrs = input.ReadBool();
							break;
						case 66u:
							functionAliases_.AddEntriesFrom(input, _map_functionAliases_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<MetaGraphDef> _parser = new MessageParser<MetaGraphDef>((Func<MetaGraphDef>)(() => new MetaGraphDef()));

		private UnknownFieldSet _unknownFields;

		public const int MetaInfoDefFieldNumber = 1;

		private Types.MetaInfoDef metaInfoDef_;

		public const int GraphDefFieldNumber = 2;

		private GraphDef graphDef_;

		public const int SaverDefFieldNumber = 3;

		private SaverDef saverDef_;

		public const int CollectionDefFieldNumber = 4;

		private static readonly Codec<string, CollectionDef> _map_collectionDef_codec = new Codec<string, CollectionDef>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<CollectionDef>(18u, Tensorboard.CollectionDef.Parser), 34u);

		private readonly MapField<string, CollectionDef> collectionDef_ = new MapField<string, CollectionDef>();

		public const int SignatureDefFieldNumber = 5;

		private static readonly Codec<string, SignatureDef> _map_signatureDef_codec = new Codec<string, SignatureDef>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<SignatureDef>(18u, Tensorboard.SignatureDef.Parser), 42u);

		private readonly MapField<string, SignatureDef> signatureDef_ = new MapField<string, SignatureDef>();

		public const int AssetFileDefFieldNumber = 6;

		private static readonly FieldCodec<AssetFileDef> _repeated_assetFileDef_codec = FieldCodec.ForMessage<AssetFileDef>(50u, Tensorboard.AssetFileDef.Parser);

		private readonly RepeatedField<AssetFileDef> assetFileDef_ = new RepeatedField<AssetFileDef>();

		public const int ObjectGraphDefFieldNumber = 7;

		private SavedObjectGraph objectGraphDef_;

		[DebuggerNonUserCode]
		public static MessageParser<MetaGraphDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => MetaGraphReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.MetaInfoDef MetaInfoDef
		{
			get
			{
				return metaInfoDef_;
			}
			set
			{
				metaInfoDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public GraphDef GraphDef
		{
			get
			{
				return graphDef_;
			}
			set
			{
				graphDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SaverDef SaverDef
		{
			get
			{
				return saverDef_;
			}
			set
			{
				saverDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, CollectionDef> CollectionDef => collectionDef_;

		[DebuggerNonUserCode]
		public MapField<string, SignatureDef> SignatureDef => signatureDef_;

		[DebuggerNonUserCode]
		public RepeatedField<AssetFileDef> AssetFileDef => assetFileDef_;

		[DebuggerNonUserCode]
		public SavedObjectGraph ObjectGraphDef
		{
			get
			{
				return objectGraphDef_;
			}
			set
			{
				objectGraphDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MetaGraphDef()
		{
		}

		[DebuggerNonUserCode]
		public MetaGraphDef(MetaGraphDef other)
			: this()
		{
			metaInfoDef_ = ((other.metaInfoDef_ != null) ? other.metaInfoDef_.Clone() : null);
			graphDef_ = ((other.graphDef_ != null) ? other.graphDef_.Clone() : null);
			saverDef_ = ((other.saverDef_ != null) ? other.saverDef_.Clone() : null);
			collectionDef_ = other.collectionDef_.Clone();
			signatureDef_ = other.signatureDef_.Clone();
			assetFileDef_ = other.assetFileDef_.Clone();
			objectGraphDef_ = ((other.objectGraphDef_ != null) ? other.objectGraphDef_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public MetaGraphDef Clone()
		{
			return new MetaGraphDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as MetaGraphDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(MetaGraphDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(MetaInfoDef, other.MetaInfoDef))
			{
				return false;
			}
			if (!object.Equals(GraphDef, other.GraphDef))
			{
				return false;
			}
			if (!object.Equals(SaverDef, other.SaverDef))
			{
				return false;
			}
			if (!CollectionDef.Equals(other.CollectionDef))
			{
				return false;
			}
			if (!SignatureDef.Equals(other.SignatureDef))
			{
				return false;
			}
			if (!assetFileDef_.Equals(other.assetFileDef_))
			{
				return false;
			}
			if (!object.Equals(ObjectGraphDef, other.ObjectGraphDef))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (metaInfoDef_ != null)
			{
				num ^= MetaInfoDef.GetHashCode();
			}
			if (graphDef_ != null)
			{
				num ^= GraphDef.GetHashCode();
			}
			if (saverDef_ != null)
			{
				num ^= SaverDef.GetHashCode();
			}
			num ^= ((object)CollectionDef).GetHashCode();
			num ^= ((object)SignatureDef).GetHashCode();
			num ^= ((object)assetFileDef_).GetHashCode();
			if (objectGraphDef_ != null)
			{
				num ^= ObjectGraphDef.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (metaInfoDef_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)MetaInfoDef);
			}
			if (graphDef_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)GraphDef);
			}
			if (saverDef_ != null)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)SaverDef);
			}
			collectionDef_.WriteTo(output, _map_collectionDef_codec);
			signatureDef_.WriteTo(output, _map_signatureDef_codec);
			assetFileDef_.WriteTo(output, _repeated_assetFileDef_codec);
			if (objectGraphDef_ != null)
			{
				output.WriteRawTag((byte)58);
				output.WriteMessage((IMessage)(object)ObjectGraphDef);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (metaInfoDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)MetaInfoDef);
			}
			if (graphDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)GraphDef);
			}
			if (saverDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)SaverDef);
			}
			num += collectionDef_.CalculateSize(_map_collectionDef_codec);
			num += signatureDef_.CalculateSize(_map_signatureDef_codec);
			num += assetFileDef_.CalculateSize(_repeated_assetFileDef_codec);
			if (objectGraphDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ObjectGraphDef);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(MetaGraphDef other)
		{
			if (other == null)
			{
				return;
			}
			if (other.metaInfoDef_ != null)
			{
				if (metaInfoDef_ == null)
				{
					MetaInfoDef = new Types.MetaInfoDef();
				}
				MetaInfoDef.MergeFrom(other.MetaInfoDef);
			}
			if (other.graphDef_ != null)
			{
				if (graphDef_ == null)
				{
					GraphDef = new GraphDef();
				}
				GraphDef.MergeFrom(other.GraphDef);
			}
			if (other.saverDef_ != null)
			{
				if (saverDef_ == null)
				{
					SaverDef = new SaverDef();
				}
				SaverDef.MergeFrom(other.SaverDef);
			}
			collectionDef_.Add((IDictionary<string, CollectionDef>)other.collectionDef_);
			signatureDef_.Add((IDictionary<string, SignatureDef>)other.signatureDef_);
			assetFileDef_.Add((IEnumerable<AssetFileDef>)other.assetFileDef_);
			if (other.objectGraphDef_ != null)
			{
				if (objectGraphDef_ == null)
				{
					ObjectGraphDef = new SavedObjectGraph();
				}
				ObjectGraphDef.MergeFrom(other.ObjectGraphDef);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (metaInfoDef_ == null)
					{
						MetaInfoDef = new Types.MetaInfoDef();
					}
					input.ReadMessage((IMessage)(object)MetaInfoDef);
					break;
				case 18u:
					if (graphDef_ == null)
					{
						GraphDef = new GraphDef();
					}
					input.ReadMessage((IMessage)(object)GraphDef);
					break;
				case 26u:
					if (saverDef_ == null)
					{
						SaverDef = new SaverDef();
					}
					input.ReadMessage((IMessage)(object)SaverDef);
					break;
				case 34u:
					collectionDef_.AddEntriesFrom(input, _map_collectionDef_codec);
					break;
				case 42u:
					signatureDef_.AddEntriesFrom(input, _map_signatureDef_codec);
					break;
				case 50u:
					assetFileDef_.AddEntriesFrom(input, _repeated_assetFileDef_codec);
					break;
				case 58u:
					if (objectGraphDef_ == null)
					{
						ObjectGraphDef = new SavedObjectGraph();
					}
					input.ReadMessage((IMessage)(object)ObjectGraphDef);
					break;
				}
			}
		}
	}
	public sealed class CollectionDef : IMessage<CollectionDef>, IMessage, IEquatable<CollectionDef>, IDeepCloneable<CollectionDef>
	{
		public enum KindOneofCase
		{
			None,
			NodeList,
			BytesList,
			Int64List,
			FloatList,
			AnyList
		}

		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class NodeList : IMessage<NodeList>, IMessage, IEquatable<NodeList>, IDeepCloneable<NodeList>
			{
				private static readonly MessageParser<NodeList> _parser = new MessageParser<NodeList>((Func<NodeList>)(() => new NodeList()));

				private UnknownFieldSet _unknownFields;

				public const int ValueFieldNumber = 1;

				private static readonly FieldCodec<string> _repeated_value_codec = FieldCodec.ForString(10u);

				private readonly RepeatedField<string> value_ = new RepeatedField<string>();

				[DebuggerNonUserCode]
				public static MessageParser<NodeList> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CollectionDef.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<string> Value => value_;

				[DebuggerNonUserCode]
				public NodeList()
				{
				}

				[DebuggerNonUserCode]
				public NodeList(NodeList other)
					: this()
				{
					value_ = other.value_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public NodeList Clone()
				{
					return new NodeList(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as NodeList);
				}

				[DebuggerNonUserCode]
				public bool Equals(NodeList other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!value_.Equals(other.value_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)value_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					value_.WriteTo(output, _repeated_value_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += value_.CalculateSize(_repeated_value_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(NodeList other)
				{
					if (other != null)
					{
						value_.Add((IEnumerable<string>)other.value_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						if (num != 10)
						{
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
						}
						else
						{
							value_.AddEntriesFrom(input, _repeated_value_codec);
						}
					}
				}
			}

			public sealed class BytesList : IMessage<BytesList>, IMessage, IEquatable<BytesList>, IDeepCloneable<BytesList>
			{
				private static readonly MessageParser<BytesList> _parser = new MessageParser<BytesList>((Func<BytesList>)(() => new BytesList()));

				private UnknownFieldSet _unknownFields;

				public const int ValueFieldNumber = 1;

				private static readonly FieldCodec<ByteString> _repeated_value_codec = FieldCodec.ForBytes(10u);

				private readonly RepeatedField<ByteString> value_ = new RepeatedField<ByteString>();

				[DebuggerNonUserCode]
				public static MessageParser<BytesList> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CollectionDef.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<ByteString> Value => value_;

				[DebuggerNonUserCode]
				public BytesList()
				{
				}

				[DebuggerNonUserCode]
				public BytesList(BytesList other)
					: this()
				{
					value_ = other.value_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public BytesList Clone()
				{
					return new BytesList(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as BytesList);
				}

				[DebuggerNonUserCode]
				public bool Equals(BytesList other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!value_.Equals(other.value_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)value_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					value_.WriteTo(output, _repeated_value_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += value_.CalculateSize(_repeated_value_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(BytesList other)
				{
					if (other != null)
					{
						value_.Add((IEnumerable<ByteString>)other.value_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						if (num != 10)
						{
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
						}
						else
						{
							value_.AddEntriesFrom(input, _repeated_value_codec);
						}
					}
				}
			}

			public sealed class Int64List : IMessage<Int64List>, IMessage, IEquatable<Int64List>, IDeepCloneable<Int64List>
			{
				private static readonly MessageParser<Int64List> _parser = new MessageParser<Int64List>((Func<Int64List>)(() => new Int64List()));

				private UnknownFieldSet _unknownFields;

				public const int ValueFieldNumber = 1;

				private static readonly FieldCodec<long> _repeated_value_codec = FieldCodec.ForInt64(10u);

				private readonly RepeatedField<long> value_ = new RepeatedField<long>();

				[DebuggerNonUserCode]
				public static MessageParser<Int64List> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CollectionDef.Descriptor.NestedTypes[2];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<long> Value => value_;

				[DebuggerNonUserCode]
				public Int64List()
				{
				}

				[DebuggerNonUserCode]
				public Int64List(Int64List other)
					: this()
				{
					value_ = other.value_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Int64List Clone()
				{
					return new Int64List(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Int64List);
				}

				[DebuggerNonUserCode]
				public bool Equals(Int64List other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!value_.Equals(other.value_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)value_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					value_.WriteTo(output, _repeated_value_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += value_.CalculateSize(_repeated_value_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Int64List other)
				{
					if (other != null)
					{
						value_.Add((IEnumerable<long>)other.value_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						if (num != 8 && num != 10)
						{
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
						}
						else
						{
							value_.AddEntriesFrom(input, _repeated_value_codec);
						}
					}
				}
			}

			public sealed class FloatList : IMessage<FloatList>, IMessage, IEquatable<FloatList>, IDeepCloneable<FloatList>
			{
				private static readonly MessageParser<FloatList> _parser = new MessageParser<FloatList>((Func<FloatList>)(() => new FloatList()));

				private UnknownFieldSet _unknownFields;

				public const int ValueFieldNumber = 1;

				private static readonly FieldCodec<float> _repeated_value_codec = FieldCodec.ForFloat(10u);

				private readonly RepeatedField<float> value_ = new RepeatedField<float>();

				[DebuggerNonUserCode]
				public static MessageParser<FloatList> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CollectionDef.Descriptor.NestedTypes[3];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<float> Value => value_;

				[DebuggerNonUserCode]
				public FloatList()
				{
				}

				[DebuggerNonUserCode]
				public FloatList(FloatList other)
					: this()
				{
					value_ = other.value_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public FloatList Clone()
				{
					return new FloatList(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as FloatList);
				}

				[DebuggerNonUserCode]
				public bool Equals(FloatList other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!value_.Equals(other.value_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)value_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					value_.WriteTo(output, _repeated_value_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += value_.CalculateSize(_repeated_value_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(FloatList other)
				{
					if (other != null)
					{
						value_.Add((IEnumerable<float>)other.value_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						if (num != 10 && num != 13)
						{
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
						}
						else
						{
							value_.AddEntriesFrom(input, _repeated_value_codec);
						}
					}
				}
			}

			public sealed class AnyList : IMessage<AnyList>, IMessage, IEquatable<AnyList>, IDeepCloneable<AnyList>
			{
				private static readonly MessageParser<AnyList> _parser = new MessageParser<AnyList>((Func<AnyList>)(() => new AnyList()));

				private UnknownFieldSet _unknownFields;

				public const int ValueFieldNumber = 1;

				private static readonly FieldCodec<Any> _repeated_value_codec = FieldCodec.ForMessage<Any>(10u, Any.Parser);

				private readonly RepeatedField<Any> value_ = new RepeatedField<Any>();

				[DebuggerNonUserCode]
				public static MessageParser<AnyList> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CollectionDef.Descriptor.NestedTypes[4];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<Any> Value => value_;

				[DebuggerNonUserCode]
				public AnyList()
				{
				}

				[DebuggerNonUserCode]
				public AnyList(AnyList other)
					: this()
				{
					value_ = other.value_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public AnyList Clone()
				{
					return new AnyList(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as AnyList);
				}

				[DebuggerNonUserCode]
				public bool Equals(AnyList other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!value_.Equals(other.value_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)value_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					value_.WriteTo(output, _repeated_value_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += value_.CalculateSize(_repeated_value_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(AnyList other)
				{
					if (other != null)
					{
						value_.Add((IEnumerable<Any>)other.value_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						if (num != 10)
						{
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
						}
						else
						{
							value_.AddEntriesFrom(input, _repeated_value_codec);
						}
					}
				}
			}
		}

		private static readonly MessageParser<CollectionDef> _parser = new MessageParser<CollectionDef>((Func<CollectionDef>)(() => new CollectionDef()));

		private UnknownFieldSet _unknownFields;

		public const int NodeListFieldNumber = 1;

		public const int BytesListFieldNumber = 2;

		public const int Int64ListFieldNumber = 3;

		public const int FloatListFieldNumber = 4;

		public const int AnyListFieldNumber = 5;

		private object kind_;

		private KindOneofCase kindCase_;

		[DebuggerNonUserCode]
		public static MessageParser<CollectionDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => MetaGraphReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.NodeList NodeList
		{
			get
			{
				if (kindCase_ != KindOneofCase.NodeList)
				{
					return null;
				}
				return (Types.NodeList)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.NodeList : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public Types.BytesList BytesList
		{
			get
			{
				if (kindCase_ != KindOneofCase.BytesList)
				{
					return null;
				}
				return (Types.BytesList)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.BytesList : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public Types.Int64List Int64List
		{
			get
			{
				if (kindCase_ != KindOneofCase.Int64List)
				{
					return null;
				}
				return (Types.Int64List)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.Int64List : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public Types.FloatList FloatList
		{
			get
			{
				if (kindCase_ != KindOneofCase.FloatList)
				{
					return null;
				}
				return (Types.FloatList)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.FloatList : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public Types.AnyList AnyList
		{
			get
			{
				if (kindCase_ != KindOneofCase.AnyList)
				{
					return null;
				}
				return (Types.AnyList)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.AnyList : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public KindOneofCase KindCase => kindCase_;

		[DebuggerNonUserCode]
		public CollectionDef()
		{
		}

		[DebuggerNonUserCode]
		public CollectionDef(CollectionDef other)
			: this()
		{
			switch (other.KindCase)
			{
			case KindOneofCase.NodeList:
				NodeList = other.NodeList.Clone();
				break;
			case KindOneofCase.BytesList:
				BytesList = other.BytesList.Clone();
				break;
			case KindOneofCase.Int64List:
				Int64List = other.Int64List.Clone();
				break;
			case KindOneofCase.FloatList:
				FloatList = other.FloatList.Clone();
				break;
			case KindOneofCase.AnyList:
				AnyList = other.AnyList.Clone();
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CollectionDef Clone()
		{
			return new CollectionDef(this);
		}

		[DebuggerNonUserCode]
		public void ClearKind()
		{
			kindCase_ = KindOneofCase.None;
			kind_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CollectionDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(CollectionDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(NodeList, other.NodeList))
			{
				return false;
			}
			if (!object.Equals(BytesList, other.BytesList))
			{
				return false;
			}
			if (!object.Equals(Int64List, other.Int64List))
			{
				return false;
			}
			if (!object.Equals(FloatList, other.FloatList))
			{
				return false;
			}
			if (!object.Equals(AnyList, other.AnyList))
			{
				return false;
			}
			if (KindCase != other.KindCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (kindCase_ == KindOneofCase.NodeList)
			{
				num ^= NodeList.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.BytesList)
			{
				num ^= BytesList.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Int64List)
			{
				num ^= Int64List.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.FloatList)
			{
				num ^= FloatList.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.AnyList)
			{
				num ^= AnyList.GetHashCode();
			}
			num ^= (int)kindCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (kindCase_ == KindOneofCase.NodeList)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)NodeList);
			}
			if (kindCase_ == KindOneofCase.BytesList)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)BytesList);
			}
			if (kindCase_ == KindOneofCase.Int64List)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)Int64List);
			}
			if (kindCase_ == KindOneofCase.FloatList)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)FloatList);
			}
			if (kindCase_ == KindOneofCase.AnyList)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)AnyList);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (kindCase_ == KindOneofCase.NodeList)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)NodeList);
			}
			if (kindCase_ == KindOneofCase.BytesList)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)BytesList);
			}
			if (kindCase_ == KindOneofCase.Int64List)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Int64List);
			}
			if (kindCase_ == KindOneofCase.FloatList)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)FloatList);
			}
			if (kindCase_ == KindOneofCase.AnyList)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)AnyList);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CollectionDef other)
		{
			if (other == null)
			{
				return;
			}
			switch (other.KindCase)
			{
			case KindOneofCase.NodeList:
				if (NodeList == null)
				{
					NodeList = new Types.NodeList();
				}
				NodeList.MergeFrom(other.NodeList);
				break;
			case KindOneofCase.BytesList:
				if (BytesList == null)
				{
					BytesList = new Types.BytesList();
				}
				BytesList.MergeFrom(other.BytesList);
				break;
			case KindOneofCase.Int64List:
				if (Int64List == null)
				{
					Int64List = new Types.Int64List();
				}
				Int64List.MergeFrom(other.Int64List);
				break;
			case KindOneofCase.FloatList:
				if (FloatList == null)
				{
					FloatList = new Types.FloatList();
				}
				FloatList.MergeFrom(other.FloatList);
				break;
			case KindOneofCase.AnyList:
				if (AnyList == null)
				{
					AnyList = new Types.AnyList();
				}
				AnyList.MergeFrom(other.AnyList);
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
				{
					Types.NodeList nodeList = new Types.NodeList();
					if (kindCase_ == KindOneofCase.NodeList)
					{
						nodeList.MergeFrom(NodeList);
					}
					input.ReadMessage((IMessage)(object)nodeList);
					NodeList = nodeList;
					break;
				}
				case 18u:
				{
					Types.BytesList bytesList = new Types.BytesList();
					if (kindCase_ == KindOneofCase.BytesList)
					{
						bytesList.MergeFrom(BytesList);
					}
					input.ReadMessage((IMessage)(object)bytesList);
					BytesList = bytesList;
					break;
				}
				case 26u:
				{
					Types.Int64List int64List = new Types.Int64List();
					if (kindCase_ == KindOneofCase.Int64List)
					{
						int64List.MergeFrom(Int64List);
					}
					input.ReadMessage((IMessage)(object)int64List);
					Int64List = int64List;
					break;
				}
				case 34u:
				{
					Types.FloatList floatList = new Types.FloatList();
					if (kindCase_ == KindOneofCase.FloatList)
					{
						floatList.MergeFrom(FloatList);
					}
					input.ReadMessage((IMessage)(object)floatList);
					FloatList = floatList;
					break;
				}
				case 42u:
				{
					Types.AnyList anyList = new Types.AnyList();
					if (kindCase_ == KindOneofCase.AnyList)
					{
						anyList.MergeFrom(AnyList);
					}
					input.ReadMessage((IMessage)(object)anyList);
					AnyList = anyList;
					break;
				}
				}
			}
		}
	}
	public sealed class TensorInfo : IMessage<TensorInfo>, IMessage, IEquatable<TensorInfo>, IDeepCloneable<TensorInfo>
	{
		public enum EncodingOneofCase
		{
			None = 0,
			Name = 1,
			CooSparse = 4,
			CompositeTensor = 5
		}

		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class CooSparse : IMessage<CooSparse>, IMessage, IEquatable<CooSparse>, IDeepCloneable<CooSparse>
			{
				private static readonly MessageParser<CooSparse> _parser = new MessageParser<CooSparse>((Func<CooSparse>)(() => new CooSparse()));

				private UnknownFieldSet _unknownFields;

				public const int ValuesTensorNameFieldNumber = 1;

				private string valuesTensorName_ = "";

				public const int IndicesTensorNameFieldNumber = 2;

				private string indicesTensorName_ = "";

				public const int DenseShapeTensorNameFieldNumber = 3;

				private string denseShapeTensorName_ = "";

				[DebuggerNonUserCode]
				public static MessageParser<CooSparse> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => TensorInfo.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string ValuesTensorName
				{
					get
					{
						return valuesTensorName_;
					}
					set
					{
						valuesTensorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string IndicesTensorName
				{
					get
					{
						return indicesTensorName_;
					}
					set
					{
						indicesTensorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string DenseShapeTensorName
				{
					get
					{
						return denseShapeTensorName_;
					}
					set
					{
						denseShapeTensorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public CooSparse()
				{
				}

				[DebuggerNonUserCode]
				public CooSparse(CooSparse other)
					: this()
				{
					valuesTensorName_ = other.valuesTensorName_;
					indicesTensorName_ = other.indicesTensorName_;
					denseShapeTensorName_ = other.denseShapeTensorName_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public CooSparse Clone()
				{
					return new CooSparse(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as CooSparse);
				}

				[DebuggerNonUserCode]
				public bool Equals(CooSparse other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (ValuesTensorName != other.ValuesTensorName)
					{
						return false;
					}
					if (IndicesTensorName != other.IndicesTensorName)
					{
						return false;
					}
					if (DenseShapeTensorName != other.DenseShapeTensorName)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (ValuesTensorName.Length != 0)
					{
						num ^= ValuesTensorName.GetHashCode();
					}
					if (IndicesTensorName.Length != 0)
					{
						num ^= IndicesTensorName.GetHashCode();
					}
					if (DenseShapeTensorName.Length != 0)
					{
						num ^= DenseShapeTensorName.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (ValuesTensorName.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(ValuesTensorName);
					}
					if (IndicesTensorName.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(IndicesTensorName);
					}
					if (DenseShapeTensorName.Length != 0)
					{
						output.WriteRawTag((byte)26);
						output.WriteString(DenseShapeTensorName);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (ValuesTensorName.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(ValuesTensorName);
					}
					if (IndicesTensorName.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(IndicesTensorName);
					}
					if (DenseShapeTensorName.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(DenseShapeTensorName);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CooSparse other)
				{
					if (other != null)
					{
						if (other.ValuesTensorName.Length != 0)
						{
							ValuesTensorName = other.ValuesTensorName;
						}
						if (other.IndicesTensorName.Length != 0)
						{
							IndicesTensorName = other.IndicesTensorName;
						}
						if (other.DenseShapeTensorName.Length != 0)
						{
							DenseShapeTensorName = other.DenseShapeTensorName;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							ValuesTensorName = input.ReadString();
							break;
						case 18u:
							IndicesTensorName = input.ReadString();
							break;
						case 26u:
							DenseShapeTensorName = input.ReadString();
							break;
						}
					}
				}
			}

			public sealed class CompositeTensor : IMessage<CompositeTensor>, IMessage, IEquatable<CompositeTensor>, IDeepCloneable<CompositeTensor>
			{
				private static readonly MessageParser<CompositeTensor> _parser = new MessageParser<CompositeTensor>((Func<CompositeTensor>)(() => new CompositeTensor()));

				private UnknownFieldSet _unknownFields;

				public const int TypeSpecFieldNumber = 1;

				private TypeSpecProto typeSpec_;

				public const int ComponentsFieldNumber = 2;

				private static readonly FieldCodec<TensorInfo> _repeated_components_codec = FieldCodec.ForMessage<TensorInfo>(18u, TensorInfo.Parser);

				private readonly RepeatedField<TensorInfo> components_ = new RepeatedField<TensorInfo>();

				[DebuggerNonUserCode]
				public static MessageParser<CompositeTensor> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => TensorInfo.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public TypeSpecProto TypeSpec
				{
					get
					{
						return typeSpec_;
					}
					set
					{
						typeSpec_ = value;
					}
				}

				[DebuggerNonUserCode]
				public RepeatedField<TensorInfo> Components => components_;

				[DebuggerNonUserCode]
				public CompositeTensor()
				{
				}

				[DebuggerNonUserCode]
				public CompositeTensor(CompositeTensor other)
					: this()
				{
					typeSpec_ = ((other.typeSpec_ != null) ? other.typeSpec_.Clone() : null);
					components_ = other.components_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public CompositeTensor Clone()
				{
					return new CompositeTensor(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as CompositeTensor);
				}

				[DebuggerNonUserCode]
				public bool Equals(CompositeTensor other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!object.Equals(TypeSpec, other.TypeSpec))
					{
						return false;
					}
					if (!components_.Equals(other.components_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (typeSpec_ != null)
					{
						num ^= TypeSpec.GetHashCode();
					}
					num ^= ((object)components_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (typeSpec_ != null)
					{
						output.WriteRawTag((byte)10);
						output.WriteMessage((IMessage)(object)TypeSpec);
					}
					components_.WriteTo(output, _repeated_components_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (typeSpec_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TypeSpec);
					}
					num += components_.CalculateSize(_repeated_components_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CompositeTensor other)
				{
					if (other == null)
					{
						return;
					}
					if (other.typeSpec_ != null)
					{
						if (typeSpec_ == null)
						{
							TypeSpec = new TypeSpecProto();
						}
						TypeSpec.MergeFrom(other.TypeSpec);
					}
					components_.Add((IEnumerable<TensorInfo>)other.components_);
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							if (typeSpec_ == null)
							{
								TypeSpec = new TypeSpecProto();
							}
							input.ReadMessage((IMessage)(object)TypeSpec);
							break;
						case 18u:
							components_.AddEntriesFrom(input, _repeated_components_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<TensorInfo> _parser = new MessageParser<TensorInfo>((Func<TensorInfo>)(() => new TensorInfo()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		public const int CooSparseFieldNumber = 4;

		public const int CompositeTensorFieldNumber = 5;

		public const int DtypeFieldNumber = 2;

		private DataType dtype_;

		public const int TensorShapeFieldNumber = 3;

		private TensorShapeProto tensorShape_;

		private object encoding_;

		private EncodingOneofCase encodingCase_;

		[DebuggerNonUserCode]
		public static MessageParser<TensorInfo> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => MetaGraphReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				if (encodingCase_ != EncodingOneofCase.Name)
				{
					return "";
				}
				return (string)encoding_;
			}
			set
			{
				encoding_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
				encodingCase_ = EncodingOneofCase.Name;
			}
		}

		[DebuggerNonUserCode]
		public Types.CooSparse CooSparse
		{
			get
			{
				if (encodingCase_ != EncodingOneofCase.CooSparse)
				{
					return null;
				}
				return (Types.CooSparse)encoding_;
			}
			set
			{
				encoding_ = value;
				encodingCase_ = ((value != null) ? EncodingOneofCase.CooSparse : EncodingOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public Types.CompositeTensor CompositeTensor
		{
			get
			{
				if (encodingCase_ != EncodingOneofCase.CompositeTensor)
				{
					return null;
				}
				return (Types.CompositeTensor)encoding_;
			}
			set
			{
				encoding_ = value;
				encodingCase_ = ((value != null) ? EncodingOneofCase.CompositeTensor : EncodingOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public DataType Dtype
		{
			get
			{
				return dtype_;
			}
			set
			{
				dtype_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto TensorShape
		{
			get
			{
				return tensorShape_;
			}
			set
			{
				tensorShape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public EncodingOneofCase EncodingCase => encodingCase_;

		[DebuggerNonUserCode]
		public TensorInfo()
		{
		}

		[DebuggerNonUserCode]
		public TensorInfo(TensorInfo other)
			: this()
		{
			dtype_ = other.dtype_;
			tensorShape_ = ((other.tensorShape_ != null) ? other.tensorShape_.Clone() : null);
			switch (other.EncodingCase)
			{
			case EncodingOneofCase.Name:
				Name = other.Name;
				break;
			case EncodingOneofCase.CooSparse:
				CooSparse = other.CooSparse.Clone();
				break;
			case EncodingOneofCase.CompositeTensor:
				CompositeTensor = other.CompositeTensor.Clone();
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TensorInfo Clone()
		{
			return new TensorInfo(this);
		}

		[DebuggerNonUserCode]
		public void ClearEncoding()
		{
			encodingCase_ = EncodingOneofCase.None;
			encoding_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TensorInfo);
		}

		[DebuggerNonUserCode]
		public bool Equals(TensorInfo other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!object.Equals(CooSparse, other.CooSparse))
			{
				return false;
			}
			if (!object.Equals(CompositeTensor, other.CompositeTensor))
			{
				return false;
			}
			if (Dtype != other.Dtype)
			{
				return false;
			}
			if (!object.Equals(TensorShape, other.TensorShape))
			{
				return false;
			}
			if (EncodingCase != other.EncodingCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (encodingCase_ == EncodingOneofCase.Name)
			{
				num ^= Name.GetHashCode();
			}
			if (encodingCase_ == EncodingOneofCase.CooSparse)
			{
				num ^= CooSparse.GetHashCode();
			}
			if (encodingCase_ == EncodingOneofCase.CompositeTensor)
			{
				num ^= CompositeTensor.GetHashCode();
			}
			if (Dtype != DataType.DtInvalid)
			{
				num ^= Dtype.GetHashCode();
			}
			if (tensorShape_ != null)
			{
				num ^= TensorShape.GetHashCode();
			}
			num ^= (int)encodingCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (encodingCase_ == EncodingOneofCase.Name)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (Dtype != DataType.DtInvalid)
			{
				output.WriteRawTag((byte)16);
				output.WriteEnum((int)Dtype);
			}
			if (tensorShape_ != null)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)TensorShape);
			}
			if (encodingCase_ == EncodingOneofCase.CooSparse)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)CooSparse);
			}
			if (encodingCase_ == EncodingOneofCase.CompositeTensor)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)CompositeTensor);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (encodingCase_ == EncodingOneofCase.Name)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (encodingCase_ == EncodingOneofCase.CooSparse)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CooSparse);
			}
			if (encodingCase_ == EncodingOneofCase.CompositeTensor)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CompositeTensor);
			}
			if (Dtype != DataType.DtInvalid)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
			}
			if (tensorShape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TensorShape);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TensorInfo other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Dtype != DataType.DtInvalid)
			{
				Dtype = other.Dtype;
			}
			if (other.tensorShape_ != null)
			{
				if (tensorShape_ == null)
				{
					TensorShape = new TensorShapeProto();
				}
				TensorShape.MergeFrom(other.TensorShape);
			}
			switch (other.EncodingCase)
			{
			case EncodingOneofCase.Name:
				Name = other.Name;
				break;
			case EncodingOneofCase.CooSparse:
				if (CooSparse == null)
				{
					CooSparse = new Types.CooSparse();
				}
				CooSparse.MergeFrom(other.CooSparse);
				break;
			case EncodingOneofCase.CompositeTensor:
				if (CompositeTensor == null)
				{
					CompositeTensor = new Types.CompositeTensor();
				}
				CompositeTensor.MergeFrom(other.CompositeTensor);
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 16u:
					Dtype = (DataType)input.ReadEnum();
					break;
				case 26u:
					if (tensorShape_ == null)
					{
						TensorShape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)TensorShape);
					break;
				case 34u:
				{
					Types.CooSparse cooSparse = new Types.CooSparse();
					if (encodingCase_ == EncodingOneofCase.CooSparse)
					{
						cooSparse.MergeFrom(CooSparse);
					}
					input.ReadMessage((IMessage)(object)cooSparse);
					CooSparse = cooSparse;
					break;
				}
				case 42u:
				{
					Types.CompositeTensor compositeTensor = new Types.CompositeTensor();
					if (encodingCase_ == EncodingOneofCase.CompositeTensor)
					{
						compositeTensor.MergeFrom(CompositeTensor);
					}
					input.ReadMessage((IMessage)(object)compositeTensor);
					CompositeTensor = compositeTensor;
					break;
				}
				}
			}
		}
	}
	public sealed class SignatureDef : IMessage<SignatureDef>, IMessage, IEquatable<SignatureDef>, IDeepCloneable<SignatureDef>
	{
		private static readonly MessageParser<SignatureDef> _parser = new MessageParser<SignatureDef>((Func<SignatureDef>)(() => new SignatureDef()));

		private UnknownFieldSet _unknownFields;

		public const int InputsFieldNumber = 1;

		private static readonly Codec<string, TensorInfo> _map_inputs_codec = new Codec<string, TensorInfo>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<TensorInfo>(18u, TensorInfo.Parser), 10u);

		private readonly MapField<string, TensorInfo> inputs_ = new MapField<string, TensorInfo>();

		public const int OutputsFieldNumber = 2;

		private static readonly Codec<string, TensorInfo> _map_outputs_codec = new Codec<string, TensorInfo>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<TensorInfo>(18u, TensorInfo.Parser), 18u);

		private readonly MapField<string, TensorInfo> outputs_ = new MapField<string, TensorInfo>();

		public const int MethodNameFieldNumber = 3;

		private string methodName_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<SignatureDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => MetaGraphReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public MapField<string, TensorInfo> Inputs => inputs_;

		[DebuggerNonUserCode]
		public MapField<string, TensorInfo> Outputs => outputs_;

		[DebuggerNonUserCode]
		public string MethodName
		{
			get
			{
				return methodName_;
			}
			set
			{
				methodName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SignatureDef()
		{
		}

		[DebuggerNonUserCode]
		public SignatureDef(SignatureDef other)
			: this()
		{
			inputs_ = other.inputs_.Clone();
			outputs_ = other.outputs_.Clone();
			methodName_ = other.methodName_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SignatureDef Clone()
		{
			return new SignatureDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SignatureDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(SignatureDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!Inputs.Equals(other.Inputs))
			{
				return false;
			}
			if (!Outputs.Equals(other.Outputs))
			{
				return false;
			}
			if (MethodName != other.MethodName)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)Inputs).GetHashCode();
			num ^= ((object)Outputs).GetHashCode();
			if (MethodName.Length != 0)
			{
				num ^= MethodName.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			inputs_.WriteTo(output, _map_inputs_codec);
			outputs_.WriteTo(output, _map_outputs_codec);
			if (MethodName.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(MethodName);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += inputs_.CalculateSize(_map_inputs_codec);
			num += outputs_.CalculateSize(_map_outputs_codec);
			if (MethodName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(MethodName);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SignatureDef other)
		{
			if (other != null)
			{
				inputs_.Add((IDictionary<string, TensorInfo>)other.inputs_);
				outputs_.Add((IDictionary<string, TensorInfo>)other.outputs_);
				if (other.MethodName.Length != 0)
				{
					MethodName = other.MethodName;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					inputs_.AddEntriesFrom(input, _map_inputs_codec);
					break;
				case 18u:
					outputs_.AddEntriesFrom(input, _map_outputs_codec);
					break;
				case 26u:
					MethodName = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class AssetFileDef : IMessage<AssetFileDef>, IMessage, IEquatable<AssetFileDef>, IDeepCloneable<AssetFileDef>
	{
		private static readonly MessageParser<AssetFileDef> _parser = new MessageParser<AssetFileDef>((Func<AssetFileDef>)(() => new AssetFileDef()));

		private UnknownFieldSet _unknownFields;

		public const int TensorInfoFieldNumber = 1;

		private TensorInfo tensorInfo_;

		public const int FilenameFieldNumber = 2;

		private string filename_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<AssetFileDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => MetaGraphReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public TensorInfo TensorInfo
		{
			get
			{
				return tensorInfo_;
			}
			set
			{
				tensorInfo_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string Filename
		{
			get
			{
				return filename_;
			}
			set
			{
				filename_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public AssetFileDef()
		{
		}

		[DebuggerNonUserCode]
		public AssetFileDef(AssetFileDef other)
			: this()
		{
			tensorInfo_ = ((other.tensorInfo_ != null) ? other.tensorInfo_.Clone() : null);
			filename_ = other.filename_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public AssetFileDef Clone()
		{
			return new AssetFileDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as AssetFileDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(AssetFileDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(TensorInfo, other.TensorInfo))
			{
				return false;
			}
			if (Filename != other.Filename)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (tensorInfo_ != null)
			{
				num ^= TensorInfo.GetHashCode();
			}
			if (Filename.Length != 0)
			{
				num ^= Filename.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (tensorInfo_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)TensorInfo);
			}
			if (Filename.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(Filename);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (tensorInfo_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TensorInfo);
			}
			if (Filename.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Filename);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(AssetFileDef other)
		{
			if (other == null)
			{
				return;
			}
			if (other.tensorInfo_ != null)
			{
				if (tensorInfo_ == null)
				{
					TensorInfo = new TensorInfo();
				}
				TensorInfo.MergeFrom(other.TensorInfo);
			}
			if (other.Filename.Length != 0)
			{
				Filename = other.Filename;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (tensorInfo_ == null)
					{
						TensorInfo = new TensorInfo();
					}
					input.ReadMessage((IMessage)(object)TensorInfo);
					break;
				case 18u:
					Filename = input.ReadString();
					break;
				}
			}
		}
	}
	public static class NodeDefReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static NodeDefReflection()
		{
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cid0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vbm9kZV9kZWYucHJvdG8SC3Rl" + "bnNvcmJvYXJkGil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vYXR0cl92YWx1" + "ZS5wcm90bxoodGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL2Z1bGxfdHlwZS5w" + "cm90byKKAwoHTm9kZURlZhIMCgRuYW1lGAEgASgJEgoKAm9wGAIgASgJEg0K" + "BWlucHV0GAMgAygJEg4KBmRldmljZRgEIAEoCRIsCgRhdHRyGAUgAygLMh4u" + "dGVuc29yYm9hcmQuTm9kZURlZi5BdHRyRW50cnkSSwoXZXhwZXJpbWVudGFs" + "X2RlYnVnX2luZm8YBiABKAsyKi50ZW5zb3Jib2FyZC5Ob2RlRGVmLkV4cGVy" + "aW1lbnRhbERlYnVnSW5mbxIzChFleHBlcmltZW50YWxfdHlwZRgHIAEoCzIY" + "LnRlbnNvcmJvYXJkLkZ1bGxUeXBlRGVmGkMKCUF0dHJFbnRyeRILCgNrZXkY" + "ASABKAkSJQoFdmFsdWUYAiABKAsyFi50ZW5zb3Jib2FyZC5BdHRyVmFsdWU6" + "AjgBGlEKFUV4cGVyaW1lbnRhbERlYnVnSW5mbxIbChNvcmlnaW5hbF9ub2Rl" + "X25hbWVzGAEgAygJEhsKE29yaWdpbmFsX2Z1bmNfbmFtZXMYAiADKAlCewoY" + "b3JnLnRlbnNvcmZsb3cuZnJhbWV3b3JrQglOb2RlUHJvdG9QAVpPZ2l0aHVi" + "LmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9nby9jb3Jl" + "L2ZyYW1ld29yay9ub2RlX2RlZl9nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[2]
			{
				AttrValueReflection.Descriptor,
				FullTypeReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(NodeDef), (MessageParser)(object)NodeDef.Parser, new string[7] { "Name", "Op", "Input", "Device", "Attr", "ExperimentalDebugInfo", "ExperimentalType" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
				{
					default(GeneratedClrTypeInfo),
					new GeneratedClrTypeInfo(typeof(NodeDef.Types.ExperimentalDebugInfo), (MessageParser)(object)NodeDef.Types.ExperimentalDebugInfo.Parser, new string[2] { "OriginalNodeNames", "OriginalFuncNames" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				})
			}));
		}
	}
	public sealed class NodeDef : IMessage<NodeDef>, IMessage, IEquatable<NodeDef>, IDeepCloneable<NodeDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class ExperimentalDebugInfo : IMessage<ExperimentalDebugInfo>, IMessage, IEquatable<ExperimentalDebugInfo>, IDeepCloneable<ExperimentalDebugInfo>
			{
				private static readonly MessageParser<ExperimentalDebugInfo> _parser = new MessageParser<ExperimentalDebugInfo>((Func<ExperimentalDebugInfo>)(() => new ExperimentalDebugInfo()));

				private UnknownFieldSet _unknownFields;

				public const int OriginalNodeNamesFieldNumber = 1;

				private static readonly FieldCodec<string> _repeated_originalNodeNames_codec = FieldCodec.ForString(10u);

				private readonly RepeatedField<string> originalNodeNames_ = new RepeatedField<string>();

				public const int OriginalFuncNamesFieldNumber = 2;

				private static readonly FieldCodec<string> _repeated_originalFuncNames_codec = FieldCodec.ForString(18u);

				private readonly RepeatedField<string> originalFuncNames_ = new RepeatedField<string>();

				[DebuggerNonUserCode]
				public static MessageParser<ExperimentalDebugInfo> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => NodeDef.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<string> OriginalNodeNames => originalNodeNames_;

				[DebuggerNonUserCode]
				public RepeatedField<string> OriginalFuncNames => originalFuncNames_;

				[DebuggerNonUserCode]
				public ExperimentalDebugInfo()
				{
				}

				[DebuggerNonUserCode]
				public ExperimentalDebugInfo(ExperimentalDebugInfo other)
					: this()
				{
					originalNodeNames_ = other.originalNodeNames_.Clone();
					originalFuncNames_ = other.originalFuncNames_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public ExperimentalDebugInfo Clone()
				{
					return new ExperimentalDebugInfo(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as ExperimentalDebugInfo);
				}

				[DebuggerNonUserCode]
				public bool Equals(ExperimentalDebugInfo other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!originalNodeNames_.Equals(other.originalNodeNames_))
					{
						return false;
					}
					if (!originalFuncNames_.Equals(other.originalFuncNames_))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)originalNodeNames_).GetHashCode();
					num ^= ((object)originalFuncNames_).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					originalNodeNames_.WriteTo(output, _repeated_originalNodeNames_codec);
					originalFuncNames_.WriteTo(output, _repeated_originalFuncNames_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += originalNodeNames_.CalculateSize(_repeated_originalNodeNames_codec);
					num += originalFuncNames_.CalculateSize(_repeated_originalFuncNames_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(ExperimentalDebugInfo other)
				{
					if (other != null)
					{
						originalNodeNames_.Add((IEnumerable<string>)other.originalNodeNames_);
						originalFuncNames_.Add((IEnumerable<string>)other.originalFuncNames_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							originalNodeNames_.AddEntriesFrom(input, _repeated_originalNodeNames_codec);
							break;
						case 18u:
							originalFuncNames_.AddEntriesFrom(input, _repeated_originalFuncNames_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<NodeDef> _parser = new MessageParser<NodeDef>((Func<NodeDef>)(() => new NodeDef()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int OpFieldNumber = 2;

		private string op_ = "";

		public const int InputFieldNumber = 3;

		private static readonly FieldCodec<string> _repeated_input_codec = FieldCodec.ForString(26u);

		private readonly RepeatedField<string> input_ = new RepeatedField<string>();

		public const int DeviceFieldNumber = 4;

		private string device_ = "";

		public const int AttrFieldNumber = 5;

		private static readonly Codec<string, AttrValue> _map_attr_codec = new Codec<string, AttrValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<AttrValue>(18u, AttrValue.Parser), 42u);

		private readonly MapField<string, AttrValue> attr_ = new MapField<string, AttrValue>();

		public const int ExperimentalDebugInfoFieldNumber = 6;

		private Types.ExperimentalDebugInfo experimentalDebugInfo_;

		public const int ExperimentalTypeFieldNumber = 7;

		private FullTypeDef experimentalType_;

		[DebuggerNonUserCode]
		public static MessageParser<NodeDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => NodeDefReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Op
		{
			get
			{
				return op_;
			}
			set
			{
				op_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> Input => input_;

		[DebuggerNonUserCode]
		public string Device
		{
			get
			{
				return device_;
			}
			set
			{
				device_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, AttrValue> Attr => attr_;

		[DebuggerNonUserCode]
		public Types.ExperimentalDebugInfo ExperimentalDebugInfo
		{
			get
			{
				return experimentalDebugInfo_;
			}
			set
			{
				experimentalDebugInfo_ = value;
			}
		}

		[DebuggerNonUserCode]
		public FullTypeDef ExperimentalType
		{
			get
			{
				return experimentalType_;
			}
			set
			{
				experimentalType_ = value;
			}
		}

		[DebuggerNonUserCode]
		public NodeDef()
		{
		}

		[DebuggerNonUserCode]
		public NodeDef(NodeDef other)
			: this()
		{
			name_ = other.name_;
			op_ = other.op_;
			input_ = other.input_.Clone();
			device_ = other.device_;
			attr_ = other.attr_.Clone();
			experimentalDebugInfo_ = ((other.experimentalDebugInfo_ != null) ? other.experimentalDebugInfo_.Clone() : null);
			experimentalType_ = ((other.experimentalType_ != null) ? other.experimentalType_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public NodeDef Clone()
		{
			return new NodeDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as NodeDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(NodeDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Op != other.Op)
			{
				return false;
			}
			if (!input_.Equals(other.input_))
			{
				return false;
			}
			if (Device != other.Device)
			{
				return false;
			}
			if (!Attr.Equals(other.Attr))
			{
				return false;
			}
			if (!object.Equals(ExperimentalDebugInfo, other.ExperimentalDebugInfo))
			{
				return false;
			}
			if (!object.Equals(ExperimentalType, other.ExperimentalType))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (Op.Length != 0)
			{
				num ^= Op.GetHashCode();
			}
			num ^= ((object)input_).GetHashCode();
			if (Device.Length != 0)
			{
				num ^= Device.GetHashCode();
			}
			num ^= ((object)Attr).GetHashCode();
			if (experimentalDebugInfo_ != null)
			{
				num ^= ExperimentalDebugInfo.GetHashCode();
			}
			if (experimentalType_ != null)
			{
				num ^= ExperimentalType.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (Op.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(Op);
			}
			input_.WriteTo(output, _repeated_input_codec);
			if (Device.Length != 0)
			{
				output.WriteRawTag((byte)34);
				output.WriteString(Device);
			}
			attr_.WriteTo(output, _map_attr_codec);
			if (experimentalDebugInfo_ != null)
			{
				output.WriteRawTag((byte)50);
				output.WriteMessage((IMessage)(object)ExperimentalDebugInfo);
			}
			if (experimentalType_ != null)
			{
				output.WriteRawTag((byte)58);
				output.WriteMessage((IMessage)(object)ExperimentalType);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (Op.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Op);
			}
			num += input_.CalculateSize(_repeated_input_codec);
			if (Device.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Device);
			}
			num += attr_.CalculateSize(_map_attr_codec);
			if (experimentalDebugInfo_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ExperimentalDebugInfo);
			}
			if (experimentalType_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ExperimentalType);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(NodeDef other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.Op.Length != 0)
			{
				Op = other.Op;
			}
			input_.Add((IEnumerable<string>)other.input_);
			if (other.Device.Length != 0)
			{
				Device = other.Device;
			}
			attr_.Add((IDictionary<string, AttrValue>)other.attr_);
			if (other.experimentalDebugInfo_ != null)
			{
				if (experimentalDebugInfo_ == null)
				{
					ExperimentalDebugInfo = new Types.ExperimentalDebugInfo();
				}
				ExperimentalDebugInfo.MergeFrom(other.ExperimentalDebugInfo);
			}
			if (other.experimentalType_ != null)
			{
				if (experimentalType_ == null)
				{
					ExperimentalType = new FullTypeDef();
				}
				ExperimentalType.MergeFrom(other.ExperimentalType);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					Op = input.ReadString();
					break;
				case 26u:
					input_.AddEntriesFrom(input, _repeated_input_codec);
					break;
				case 34u:
					Device = input.ReadString();
					break;
				case 42u:
					attr_.AddEntriesFrom(input, _map_attr_codec);
					break;
				case 50u:
					if (experimentalDebugInfo_ == null)
					{
						ExperimentalDebugInfo = new Types.ExperimentalDebugInfo();
					}
					input.ReadMessage((IMessage)(object)ExperimentalDebugInfo);
					break;
				case 58u:
					if (experimentalType_ == null)
					{
						ExperimentalType = new FullTypeDef();
					}
					input.ReadMessage((IMessage)(object)ExperimentalType);
					break;
				}
			}
		}
	}
	public static class OpDefReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static OpDefReflection()
		{
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Expected O, but got Unknown
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Expected O, but got Unknown
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Expected O, but got Unknown
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vb3BfZGVmLnByb3RvEgt0ZW5z" + "b3Jib2FyZBopdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL2F0dHJfdmFsdWUu" + "cHJvdG8aKHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9mdWxsX3R5cGUucHJv" + "dG8aLnRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9yZXNvdXJjZV9oYW5kbGUu" + "cHJvdG8aJHRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90eXBlcy5wcm90byL8" + "BgoFT3BEZWYSDAoEbmFtZRgBIAEoCRIsCglpbnB1dF9hcmcYAiADKAsyGS50" + "ZW5zb3Jib2FyZC5PcERlZi5BcmdEZWYSLQoKb3V0cHV0X2FyZxgDIAMoCzIZ" + "LnRlbnNvcmJvYXJkLk9wRGVmLkFyZ0RlZhIWCg5jb250cm9sX291dHB1dBgU" + "IAMoCRIoCgRhdHRyGAQgAygLMhoudGVuc29yYm9hcmQuT3BEZWYuQXR0ckRl" + "ZhIvCgtkZXByZWNhdGlvbhgIIAEoCzIaLnRlbnNvcmJvYXJkLk9wRGVwcmVj" + "YXRpb24SDwoHc3VtbWFyeRgFIAEoCRITCgtkZXNjcmlwdGlvbhgGIAEoCRIW" + "Cg5pc19jb21tdXRhdGl2ZRgSIAEoCBIUCgxpc19hZ2dyZWdhdGUYECABKAgS" + "EwoLaXNfc3RhdGVmdWwYESABKAgSIgoaYWxsb3dzX3VuaW5pdGlhbGl6ZWRf" + "aW5wdXQYEyABKAgSJAocaXNfZGlzdHJpYnV0ZWRfY29tbXVuaWNhdGlvbhgV" + "IAEoCBqfAgoGQXJnRGVmEgwKBG5hbWUYASABKAkSEwoLZGVzY3JpcHRpb24Y" + "AiABKAkSIwoEdHlwZRgDIAEoDjIVLnRlbnNvcmJvYXJkLkRhdGFUeXBlEhEK" + "CXR5cGVfYXR0chgEIAEoCRITCgtudW1iZXJfYXR0chgFIAEoCRIWCg50eXBl" + "X2xpc3RfYXR0chgGIAEoCRJDCgtoYW5kbGVfZGF0YRgHIAMoCzIuLnRlbnNv" + "cmJvYXJkLlJlc291cmNlSGFuZGxlUHJvdG8uRHR5cGVBbmRTaGFwZRIOCgZp" + "c19yZWYYECABKAgSOAoWZXhwZXJpbWVudGFsX2Z1bGxfdHlwZRgRIAEoCzIY" + "LnRlbnNvcmJvYXJkLkZ1bGxUeXBlRGVmGr8BCgdBdHRyRGVmEgwKBG5hbWUY" + "ASABKAkSDAoEdHlwZRgCIAEoCRItCg1kZWZhdWx0X3ZhbHVlGAMgASgLMhYu" + "dGVuc29yYm9hcmQuQXR0clZhbHVlEhMKC2Rlc2NyaXB0aW9uGAQgASgJEhMK" + "C2hhc19taW5pbXVtGAUgASgIEg8KB21pbmltdW0YBiABKAMSLgoOYWxsb3dl" + "ZF92YWx1ZXMYByABKAsyFi50ZW5zb3Jib2FyZC5BdHRyVmFsdWUiNQoNT3BE" + "ZXByZWNhdGlvbhIPCgd2ZXJzaW9uGAEgASgFEhMKC2V4cGxhbmF0aW9uGAIg" + "ASgJIigKBk9wTGlzdBIeCgJvcBgBIAMoCzISLnRlbnNvcmJvYXJkLk9wRGVm" + "QnsKGG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0ILT3BEZWZQcm90b3NQAVpN" + "Z2l0aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9n" + "by9jb3JlL2ZyYW1ld29yay9vcF9kZWZfZ29fcHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[4]
			{
				AttrValueReflection.Descriptor,
				FullTypeReflection.Descriptor,
				ResourceHandleReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[3]
			{
				new GeneratedClrTypeInfo(typeof(OpDef), (MessageParser)(object)OpDef.Parser, new string[13]
				{
					"Name", "InputArg", "OutputArg", "ControlOutput", "Attr", "Deprecation", "Summary", "Description", "IsCommutative", "IsAggregate",
					"IsStateful", "AllowsUninitializedInput", "IsDistributedCommunication"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
				{
					new GeneratedClrTypeInfo(typeof(OpDef.Types.ArgDef), (MessageParser)(object)OpDef.Types.ArgDef.Parser, new string[9] { "Name", "Description", "Type", "TypeAttr", "NumberAttr", "TypeListAttr", "HandleData", "IsRef", "ExperimentalFullType" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(OpDef.Types.AttrDef), (MessageParser)(object)OpDef.Types.AttrDef.Parser, new string[7] { "Name", "Type", "DefaultValue", "Description", "HasMinimum", "Minimum", "AllowedValues" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(OpDeprecation), (MessageParser)(object)OpDeprecation.Parser, new string[2] { "Version", "Explanation" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(OpList), (MessageParser)(object)OpList.Parser, new string[1] { "Op" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class OpDef : IMessage<OpDef>, IMessage, IEquatable<OpDef>, IDeepCloneable<OpDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class ArgDef : IMessage<ArgDef>, IMessage, IEquatable<ArgDef>, IDeepCloneable<ArgDef>
			{
				private static readonly MessageParser<ArgDef> _parser = new MessageParser<ArgDef>((Func<ArgDef>)(() => new ArgDef()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int DescriptionFieldNumber = 2;

				private string description_ = "";

				public const int TypeFieldNumber = 3;

				private DataType type_;

				public const int TypeAttrFieldNumber = 4;

				private string typeAttr_ = "";

				public const int NumberAttrFieldNumber = 5;

				private string numberAttr_ = "";

				public const int TypeListAttrFieldNumber = 6;

				private string typeListAttr_ = "";

				public const int HandleDataFieldNumber = 7;

				private static readonly FieldCodec<ResourceHandleProto.Types.DtypeAndShape> _repeated_handleData_codec = FieldCodec.ForMessage<ResourceHandleProto.Types.DtypeAndShape>(58u, ResourceHandleProto.Types.DtypeAndShape.Parser);

				private readonly RepeatedField<ResourceHandleProto.Types.DtypeAndShape> handleData_ = new RepeatedField<ResourceHandleProto.Types.DtypeAndShape>();

				public const int IsRefFieldNumber = 16;

				private bool isRef_;

				public const int ExperimentalFullTypeFieldNumber = 17;

				private FullTypeDef experimentalFullType_;

				[DebuggerNonUserCode]
				public static MessageParser<ArgDef> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => OpDef.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string Description
				{
					get
					{
						return description_;
					}
					set
					{
						description_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public DataType Type
				{
					get
					{
						return type_;
					}
					set
					{
						type_ = value;
					}
				}

				[DebuggerNonUserCode]
				public string TypeAttr
				{
					get
					{
						return typeAttr_;
					}
					set
					{
						typeAttr_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string NumberAttr
				{
					get
					{
						return numberAttr_;
					}
					set
					{
						numberAttr_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string TypeListAttr
				{
					get
					{
						return typeListAttr_;
					}
					set
					{
						typeListAttr_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public RepeatedField<ResourceHandleProto.Types.DtypeAndShape> HandleData => handleData_;

				[DebuggerNonUserCode]
				public bool IsRef
				{
					get
					{
						return isRef_;
					}
					set
					{
						isRef_ = value;
					}
				}

				[DebuggerNonUserCode]
				public FullTypeDef ExperimentalFullType
				{
					get
					{
						return experimentalFullType_;
					}
					set
					{
						experimentalFullType_ = value;
					}
				}

				[DebuggerNonUserCode]
				public ArgDef()
				{
				}

				[DebuggerNonUserCode]
				public ArgDef(ArgDef other)
					: this()
				{
					name_ = other.name_;
					description_ = other.description_;
					type_ = other.type_;
					typeAttr_ = other.typeAttr_;
					numberAttr_ = other.numberAttr_;
					typeListAttr_ = other.typeListAttr_;
					handleData_ = other.handleData_.Clone();
					isRef_ = other.isRef_;
					experimentalFullType_ = ((other.experimentalFullType_ != null) ? other.experimentalFullType_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public ArgDef Clone()
				{
					return new ArgDef(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as ArgDef);
				}

				[DebuggerNonUserCode]
				public bool Equals(ArgDef other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (Description != other.Description)
					{
						return false;
					}
					if (Type != other.Type)
					{
						return false;
					}
					if (TypeAttr != other.TypeAttr)
					{
						return false;
					}
					if (NumberAttr != other.NumberAttr)
					{
						return false;
					}
					if (TypeListAttr != other.TypeListAttr)
					{
						return false;
					}
					if (!handleData_.Equals(other.handleData_))
					{
						return false;
					}
					if (IsRef != other.IsRef)
					{
						return false;
					}
					if (!object.Equals(ExperimentalFullType, other.ExperimentalFullType))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (Description.Length != 0)
					{
						num ^= Description.GetHashCode();
					}
					if (Type != DataType.DtInvalid)
					{
						num ^= Type.GetHashCode();
					}
					if (TypeAttr.Length != 0)
					{
						num ^= TypeAttr.GetHashCode();
					}
					if (NumberAttr.Length != 0)
					{
						num ^= NumberAttr.GetHashCode();
					}
					if (TypeListAttr.Length != 0)
					{
						num ^= TypeListAttr.GetHashCode();
					}
					num ^= ((object)handleData_).GetHashCode();
					if (IsRef)
					{
						num ^= IsRef.GetHashCode();
					}
					if (experimentalFullType_ != null)
					{
						num ^= ExperimentalFullType.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					if (Description.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(Description);
					}
					if (Type != DataType.DtInvalid)
					{
						output.WriteRawTag((byte)24);
						output.WriteEnum((int)Type);
					}
					if (TypeAttr.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteString(TypeAttr);
					}
					if (NumberAttr.Length != 0)
					{
						output.WriteRawTag((byte)42);
						output.WriteString(NumberAttr);
					}
					if (TypeListAttr.Length != 0)
					{
						output.WriteRawTag((byte)50);
						output.WriteString(TypeListAttr);
					}
					handleData_.WriteTo(output, _repeated_handleData_codec);
					if (IsRef)
					{
						output.WriteRawTag((byte)128, (byte)1);
						output.WriteBool(IsRef);
					}
					if (experimentalFullType_ != null)
					{
						output.WriteRawTag((byte)138, (byte)1);
						output.WriteMessage((IMessage)(object)ExperimentalFullType);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (Description.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Description);
					}
					if (Type != DataType.DtInvalid)
					{
						num += 1 + CodedOutputStream.ComputeEnumSize((int)Type);
					}
					if (TypeAttr.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(TypeAttr);
					}
					if (NumberAttr.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(NumberAttr);
					}
					if (TypeListAttr.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(TypeListAttr);
					}
					num += handleData_.CalculateSize(_repeated_handleData_codec);
					if (IsRef)
					{
						num += 3;
					}
					if (experimentalFullType_ != null)
					{
						num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ExperimentalFullType);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(ArgDef other)
				{
					if (other == null)
					{
						return;
					}
					if (other.Name.Length != 0)
					{
						Name = other.Name;
					}
					if (other.Description.Length != 0)
					{
						Description = other.Description;
					}
					if (other.Type != DataType.DtInvalid)
					{
						Type = other.Type;
					}
					if (other.TypeAttr.Length != 0)
					{
						TypeAttr = other.TypeAttr;
					}
					if (other.NumberAttr.Length != 0)
					{
						NumberAttr = other.NumberAttr;
					}
					if (other.TypeListAttr.Length != 0)
					{
						TypeListAttr = other.TypeListAttr;
					}
					handleData_.Add((IEnumerable<ResourceHandleProto.Types.DtypeAndShape>)other.handleData_);
					if (other.IsRef)
					{
						IsRef = other.IsRef;
					}
					if (other.experimentalFullType_ != null)
					{
						if (experimentalFullType_ == null)
						{
							ExperimentalFullType = new FullTypeDef();
						}
						ExperimentalFullType.MergeFrom(other.ExperimentalFullType);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 18u:
							Description = input.ReadString();
							break;
						case 24u:
							Type = (DataType)input.ReadEnum();
							break;
						case 34u:
							TypeAttr = input.ReadString();
							break;
						case 42u:
							NumberAttr = input.ReadString();
							break;
						case 50u:
							TypeListAttr = input.ReadString();
							break;
						case 58u:
							handleData_.AddEntriesFrom(input, _repeated_handleData_codec);
							break;
						case 128u:
							IsRef = input.ReadBool();
							break;
						case 138u:
							if (experimentalFullType_ == null)
							{
								ExperimentalFullType = new FullTypeDef();
							}
							input.ReadMessage((IMessage)(object)ExperimentalFullType);
							break;
						}
					}
				}
			}

			public sealed class AttrDef : IMessage<AttrDef>, IMessage, IEquatable<AttrDef>, IDeepCloneable<AttrDef>
			{
				private static readonly MessageParser<AttrDef> _parser = new MessageParser<AttrDef>((Func<AttrDef>)(() => new AttrDef()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int TypeFieldNumber = 2;

				private string type_ = "";

				public const int DefaultValueFieldNumber = 3;

				private AttrValue defaultValue_;

				public const int DescriptionFieldNumber = 4;

				private string description_ = "";

				public const int HasMinimumFieldNumber = 5;

				private bool hasMinimum_;

				public const int MinimumFieldNumber = 6;

				private long minimum_;

				public const int AllowedValuesFieldNumber = 7;

				private AttrValue allowedValues_;

				[DebuggerNonUserCode]
				public static MessageParser<AttrDef> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => OpDef.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string Type
				{
					get
					{
						return type_;
					}
					set
					{
						type_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public AttrValue DefaultValue
				{
					get
					{
						return defaultValue_;
					}
					set
					{
						defaultValue_ = value;
					}
				}

				[DebuggerNonUserCode]
				public string Description
				{
					get
					{
						return description_;
					}
					set
					{
						description_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public bool HasMinimum
				{
					get
					{
						return hasMinimum_;
					}
					set
					{
						hasMinimum_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long Minimum
				{
					get
					{
						return minimum_;
					}
					set
					{
						minimum_ = value;
					}
				}

				[DebuggerNonUserCode]
				public AttrValue AllowedValues
				{
					get
					{
						return allowedValues_;
					}
					set
					{
						allowedValues_ = value;
					}
				}

				[DebuggerNonUserCode]
				public AttrDef()
				{
				}

				[DebuggerNonUserCode]
				public AttrDef(AttrDef other)
					: this()
				{
					name_ = other.name_;
					type_ = other.type_;
					defaultValue_ = ((other.defaultValue_ != null) ? other.defaultValue_.Clone() : null);
					description_ = other.description_;
					hasMinimum_ = other.hasMinimum_;
					minimum_ = other.minimum_;
					allowedValues_ = ((other.allowedValues_ != null) ? other.allowedValues_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public AttrDef Clone()
				{
					return new AttrDef(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as AttrDef);
				}

				[DebuggerNonUserCode]
				public bool Equals(AttrDef other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (Type != other.Type)
					{
						return false;
					}
					if (!object.Equals(DefaultValue, other.DefaultValue))
					{
						return false;
					}
					if (Description != other.Description)
					{
						return false;
					}
					if (HasMinimum != other.HasMinimum)
					{
						return false;
					}
					if (Minimum != other.Minimum)
					{
						return false;
					}
					if (!object.Equals(AllowedValues, other.AllowedValues))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (Type.Length != 0)
					{
						num ^= Type.GetHashCode();
					}
					if (defaultValue_ != null)
					{
						num ^= DefaultValue.GetHashCode();
					}
					if (Description.Length != 0)
					{
						num ^= Description.GetHashCode();
					}
					if (HasMinimum)
					{
						num ^= HasMinimum.GetHashCode();
					}
					if (Minimum != 0L)
					{
						num ^= Minimum.GetHashCode();
					}
					if (allowedValues_ != null)
					{
						num ^= AllowedValues.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					if (Type.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(Type);
					}
					if (defaultValue_ != null)
					{
						output.WriteRawTag((byte)26);
						output.WriteMessage((IMessage)(object)DefaultValue);
					}
					if (Description.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteString(Description);
					}
					if (HasMinimum)
					{
						output.WriteRawTag((byte)40);
						output.WriteBool(HasMinimum);
					}
					if (Minimum != 0L)
					{
						output.WriteRawTag((byte)48);
						output.WriteInt64(Minimum);
					}
					if (allowedValues_ != null)
					{
						output.WriteRawTag((byte)58);
						output.WriteMessage((IMessage)(object)AllowedValues);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (Type.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Type);
					}
					if (defaultValue_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)DefaultValue);
					}
					if (Description.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Description);
					}
					if (HasMinimum)
					{
						num += 2;
					}
					if (Minimum != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(Minimum);
					}
					if (allowedValues_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)AllowedValues);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(AttrDef other)
				{
					if (other == null)
					{
						return;
					}
					if (other.Name.Length != 0)
					{
						Name = other.Name;
					}
					if (other.Type.Length != 0)
					{
						Type = other.Type;
					}
					if (other.defaultValue_ != null)
					{
						if (defaultValue_ == null)
						{
							DefaultValue = new AttrValue();
						}
						DefaultValue.MergeFrom(other.DefaultValue);
					}
					if (other.Description.Length != 0)
					{
						Description = other.Description;
					}
					if (other.HasMinimum)
					{
						HasMinimum = other.HasMinimum;
					}
					if (other.Minimum != 0L)
					{
						Minimum = other.Minimum;
					}
					if (other.allowedValues_ != null)
					{
						if (allowedValues_ == null)
						{
							AllowedValues = new AttrValue();
						}
						AllowedValues.MergeFrom(other.AllowedValues);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 18u:
							Type = input.ReadString();
							break;
						case 26u:
							if (defaultValue_ == null)
							{
								DefaultValue = new AttrValue();
							}
							input.ReadMessage((IMessage)(object)DefaultValue);
							break;
						case 34u:
							Description = input.ReadString();
							break;
						case 40u:
							HasMinimum = input.ReadBool();
							break;
						case 48u:
							Minimum = input.ReadInt64();
							break;
						case 58u:
							if (allowedValues_ == null)
							{
								AllowedValues = new AttrValue();
							}
							input.ReadMessage((IMessage)(object)AllowedValues);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<OpDef> _parser = new MessageParser<OpDef>((Func<OpDef>)(() => new OpDef()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int InputArgFieldNumber = 2;

		private static readonly FieldCodec<Types.ArgDef> _repeated_inputArg_codec = FieldCodec.ForMessage<Types.ArgDef>(18u, Types.ArgDef.Parser);

		private readonly RepeatedField<Types.ArgDef> inputArg_ = new RepeatedField<Types.ArgDef>();

		public const int OutputArgFieldNumber = 3;

		private static readonly FieldCodec<Types.ArgDef> _repeated_outputArg_codec = FieldCodec.ForMessage<Types.ArgDef>(26u, Types.ArgDef.Parser);

		private readonly RepeatedField<Types.ArgDef> outputArg_ = new RepeatedField<Types.ArgDef>();

		public const int ControlOutputFieldNumber = 20;

		private static readonly FieldCodec<string> _repeated_controlOutput_codec = FieldCodec.ForString(162u);

		private readonly RepeatedField<string> controlOutput_ = new RepeatedField<string>();

		public const int AttrFieldNumber = 4;

		private static readonly FieldCodec<Types.AttrDef> _repeated_attr_codec = FieldCodec.ForMessage<Types.AttrDef>(34u, Types.AttrDef.Parser);

		private readonly RepeatedField<Types.AttrDef> attr_ = new RepeatedField<Types.AttrDef>();

		public const int DeprecationFieldNumber = 8;

		private OpDeprecation deprecation_;

		public const int SummaryFieldNumber = 5;

		private string summary_ = "";

		public const int DescriptionFieldNumber = 6;

		private string description_ = "";

		public const int IsCommutativeFieldNumber = 18;

		private bool isCommutative_;

		public const int IsAggregateFieldNumber = 16;

		private bool isAggregate_;

		public const int IsStatefulFieldNumber = 17;

		private bool isStateful_;

		public const int AllowsUninitializedInputFieldNumber = 19;

		private bool allowsUninitializedInput_;

		public const int IsDistributedCommunicationFieldNumber = 21;

		private bool isDistributedCommunication_;

		[DebuggerNonUserCode]
		public static MessageParser<OpDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => OpDefReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<Types.ArgDef> InputArg => inputArg_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.ArgDef> OutputArg => outputArg_;

		[DebuggerNonUserCode]
		public RepeatedField<string> ControlOutput => controlOutput_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.AttrDef> Attr => attr_;

		[DebuggerNonUserCode]
		public OpDeprecation Deprecation
		{
			get
			{
				return deprecation_;
			}
			set
			{
				deprecation_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string Summary
		{
			get
			{
				return summary_;
			}
			set
			{
				summary_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Description
		{
			get
			{
				return description_;
			}
			set
			{
				description_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public bool IsCommutative
		{
			get
			{
				return isCommutative_;
			}
			set
			{
				isCommutative_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool IsAggregate
		{
			get
			{
				return isAggregate_;
			}
			set
			{
				isAggregate_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool IsStateful
		{
			get
			{
				return isStateful_;
			}
			set
			{
				isStateful_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool AllowsUninitializedInput
		{
			get
			{
				return allowsUninitializedInput_;
			}
			set
			{
				allowsUninitializedInput_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool IsDistributedCommunication
		{
			get
			{
				return isDistributedCommunication_;
			}
			set
			{
				isDistributedCommunication_ = value;
			}
		}

		[DebuggerNonUserCode]
		public OpDef()
		{
		}

		[DebuggerNonUserCode]
		public OpDef(OpDef other)
			: this()
		{
			name_ = other.name_;
			inputArg_ = other.inputArg_.Clone();
			outputArg_ = other.outputArg_.Clone();
			controlOutput_ = other.controlOutput_.Clone();
			attr_ = other.attr_.Clone();
			deprecation_ = ((other.deprecation_ != null) ? other.deprecation_.Clone() : null);
			summary_ = other.summary_;
			description_ = other.description_;
			isCommutative_ = other.isCommutative_;
			isAggregate_ = other.isAggregate_;
			isStateful_ = other.isStateful_;
			allowsUninitializedInput_ = other.allowsUninitializedInput_;
			isDistributedCommunication_ = other.isDistributedCommunication_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public OpDef Clone()
		{
			return new OpDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as OpDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(OpDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!inputArg_.Equals(other.inputArg_))
			{
				return false;
			}
			if (!outputArg_.Equals(other.outputArg_))
			{
				return false;
			}
			if (!controlOutput_.Equals(other.controlOutput_))
			{
				return false;
			}
			if (!attr_.Equals(other.attr_))
			{
				return false;
			}
			if (!object.Equals(Deprecation, other.Deprecation))
			{
				return false;
			}
			if (Summary != other.Summary)
			{
				return false;
			}
			if (Description != other.Description)
			{
				return false;
			}
			if (IsCommutative != other.IsCommutative)
			{
				return false;
			}
			if (IsAggregate != other.IsAggregate)
			{
				return false;
			}
			if (IsStateful != other.IsStateful)
			{
				return false;
			}
			if (AllowsUninitializedInput != other.AllowsUninitializedInput)
			{
				return false;
			}
			if (IsDistributedCommunication != other.IsDistributedCommunication)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= ((object)inputArg_).GetHashCode();
			num ^= ((object)outputArg_).GetHashCode();
			num ^= ((object)controlOutput_).GetHashCode();
			num ^= ((object)attr_).GetHashCode();
			if (deprecation_ != null)
			{
				num ^= Deprecation.GetHashCode();
			}
			if (Summary.Length != 0)
			{
				num ^= Summary.GetHashCode();
			}
			if (Description.Length != 0)
			{
				num ^= Description.GetHashCode();
			}
			if (IsCommutative)
			{
				num ^= IsCommutative.GetHashCode();
			}
			if (IsAggregate)
			{
				num ^= IsAggregate.GetHashCode();
			}
			if (IsStateful)
			{
				num ^= IsStateful.GetHashCode();
			}
			if (AllowsUninitializedInput)
			{
				num ^= AllowsUninitializedInput.GetHashCode();
			}
			if (IsDistributedCommunication)
			{
				num ^= IsDistributedCommunication.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			inputArg_.WriteTo(output, _repeated_inputArg_codec);
			outputArg_.WriteTo(output, _repeated_outputArg_codec);
			attr_.WriteTo(output, _repeated_attr_codec);
			if (Summary.Length != 0)
			{
				output.WriteRawTag((byte)42);
				output.WriteString(Summary);
			}
			if (Description.Length != 0)
			{
				output.WriteRawTag((byte)50);
				output.WriteString(Description);
			}
			if (deprecation_ != null)
			{
				output.WriteRawTag((byte)66);
				output.WriteMessage((IMessage)(object)Deprecation);
			}
			if (IsAggregate)
			{
				output.WriteRawTag((byte)128, (byte)1);
				output.WriteBool(IsAggregate);
			}
			if (IsStateful)
			{
				output.WriteRawTag((byte)136, (byte)1);
				output.WriteBool(IsStateful);
			}
			if (IsCommutative)
			{
				output.WriteRawTag((byte)144, (byte)1);
				output.WriteBool(IsCommutative);
			}
			if (AllowsUninitializedInput)
			{
				output.WriteRawTag((byte)152, (byte)1);
				output.WriteBool(AllowsUninitializedInput);
			}
			controlOutput_.WriteTo(output, _repeated_controlOutput_codec);
			if (IsDistributedCommunication)
			{
				output.WriteRawTag((byte)168, (byte)1);
				output.WriteBool(IsDistributedCommunication);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += inputArg_.CalculateSize(_repeated_inputArg_codec);
			num += outputArg_.CalculateSize(_repeated_outputArg_codec);
			num += controlOutput_.CalculateSize(_repeated_controlOutput_codec);
			num += attr_.CalculateSize(_repeated_attr_codec);
			if (deprecation_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Deprecation);
			}
			if (Summary.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Summary);
			}
			if (Description.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Description);
			}
			if (IsCommutative)
			{
				num += 3;
			}
			if (IsAggregate)
			{
				num += 3;
			}
			if (IsStateful)
			{
				num += 3;
			}
			if (AllowsUninitializedInput)
			{
				num += 3;
			}
			if (IsDistributedCommunication)
			{
				num += 3;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(OpDef other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			inputArg_.Add((IEnumerable<Types.ArgDef>)other.inputArg_);
			outputArg_.Add((IEnumerable<Types.ArgDef>)other.outputArg_);
			controlOutput_.Add((IEnumerable<string>)other.controlOutput_);
			attr_.Add((IEnumerable<Types.AttrDef>)other.attr_);
			if (other.deprecation_ != null)
			{
				if (deprecation_ == null)
				{
					Deprecation = new OpDeprecation();
				}
				Deprecation.MergeFrom(other.Deprecation);
			}
			if (other.Summary.Length != 0)
			{
				Summary = other.Summary;
			}
			if (other.Description.Length != 0)
			{
				Description = other.Description;
			}
			if (other.IsCommutative)
			{
				IsCommutative = other.IsCommutative;
			}
			if (other.IsAggregate)
			{
				IsAggregate = other.IsAggregate;
			}
			if (other.IsStateful)
			{
				IsStateful = other.IsStateful;
			}
			if (other.AllowsUninitializedInput)
			{
				AllowsUninitializedInput = other.AllowsUninitializedInput;
			}
			if (other.IsDistributedCommunication)
			{
				IsDistributedCommunication = other.IsDistributedCommunication;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					inputArg_.AddEntriesFrom(input, _repeated_inputArg_codec);
					break;
				case 26u:
					outputArg_.AddEntriesFrom(input, _repeated_outputArg_codec);
					break;
				case 34u:
					attr_.AddEntriesFrom(input, _repeated_attr_codec);
					break;
				case 42u:
					Summary = input.ReadString();
					break;
				case 50u:
					Description = input.ReadString();
					break;
				case 66u:
					if (deprecation_ == null)
					{
						Deprecation = new OpDeprecation();
					}
					input.ReadMessage((IMessage)(object)Deprecation);
					break;
				case 128u:
					IsAggregate = input.ReadBool();
					break;
				case 136u:
					IsStateful = input.ReadBool();
					break;
				case 144u:
					IsCommutative = input.ReadBool();
					break;
				case 152u:
					AllowsUninitializedInput = input.ReadBool();
					break;
				case 162u:
					controlOutput_.AddEntriesFrom(input, _repeated_controlOutput_codec);
					break;
				case 168u:
					IsDistributedCommunication = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class OpDeprecation : IMessage<OpDeprecation>, IMessage, IEquatable<OpDeprecation>, IDeepCloneable<OpDeprecation>
	{
		private static readonly MessageParser<OpDeprecation> _parser = new MessageParser<OpDeprecation>((Func<OpDeprecation>)(() => new OpDeprecation()));

		private UnknownFieldSet _unknownFields;

		public const int VersionFieldNumber = 1;

		private int version_;

		public const int ExplanationFieldNumber = 2;

		private string explanation_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<OpDeprecation> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => OpDefReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int Version
		{
			get
			{
				return version_;
			}
			set
			{
				version_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string Explanation
		{
			get
			{
				return explanation_;
			}
			set
			{
				explanation_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public OpDeprecation()
		{
		}

		[DebuggerNonUserCode]
		public OpDeprecation(OpDeprecation other)
			: this()
		{
			version_ = other.version_;
			explanation_ = other.explanation_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public OpDeprecation Clone()
		{
			return new OpDeprecation(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as OpDeprecation);
		}

		[DebuggerNonUserCode]
		public bool Equals(OpDeprecation other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Version != other.Version)
			{
				return false;
			}
			if (Explanation != other.Explanation)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Version != 0)
			{
				num ^= Version.GetHashCode();
			}
			if (Explanation.Length != 0)
			{
				num ^= Explanation.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Version != 0)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt32(Version);
			}
			if (Explanation.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(Explanation);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Version != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Version);
			}
			if (Explanation.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Explanation);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(OpDeprecation other)
		{
			if (other != null)
			{
				if (other.Version != 0)
				{
					Version = other.Version;
				}
				if (other.Explanation.Length != 0)
				{
					Explanation = other.Explanation;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Version = input.ReadInt32();
					break;
				case 18u:
					Explanation = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class OpList : IMessage<OpList>, IMessage, IEquatable<OpList>, IDeepCloneable<OpList>
	{
		private static readonly MessageParser<OpList> _parser = new MessageParser<OpList>((Func<OpList>)(() => new OpList()));

		private UnknownFieldSet _unknownFields;

		public const int OpFieldNumber = 1;

		private static readonly FieldCodec<OpDef> _repeated_op_codec = FieldCodec.ForMessage<OpDef>(10u, OpDef.Parser);

		private readonly RepeatedField<OpDef> op_ = new RepeatedField<OpDef>();

		[DebuggerNonUserCode]
		public static MessageParser<OpList> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => OpDefReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<OpDef> Op => op_;

		[DebuggerNonUserCode]
		public OpList()
		{
		}

		[DebuggerNonUserCode]
		public OpList(OpList other)
			: this()
		{
			op_ = other.op_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public OpList Clone()
		{
			return new OpList(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as OpList);
		}

		[DebuggerNonUserCode]
		public bool Equals(OpList other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!op_.Equals(other.op_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)op_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			op_.WriteTo(output, _repeated_op_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += op_.CalculateSize(_repeated_op_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(OpList other)
		{
			if (other != null)
			{
				op_.Add((IEnumerable<OpDef>)other.op_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					op_.AddEntriesFrom(input, _repeated_op_codec);
				}
			}
		}
	}
	public static class ResourceHandleReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static ResourceHandleReflection()
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Ci50ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vcmVzb3VyY2VfaGFuZGxlLnBy" + "b3RvEgt0ZW5zb3Jib2FyZBordGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3Rl" + "bnNvcl9zaGFwZS5wcm90bxokdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3R5" + "cGVzLnByb3RvIqgCChNSZXNvdXJjZUhhbmRsZVByb3RvEg4KBmRldmljZRgB" + "IAEoCRIRCgljb250YWluZXIYAiABKAkSDAoEbmFtZRgDIAEoCRIRCgloYXNo" + "X2NvZGUYBCABKAQSFwoPbWF5YmVfdHlwZV9uYW1lGAUgASgJEkkKEWR0eXBl" + "c19hbmRfc2hhcGVzGAYgAygLMi4udGVuc29yYm9hcmQuUmVzb3VyY2VIYW5k" + "bGVQcm90by5EdHlwZUFuZFNoYXBlGmMKDUR0eXBlQW5kU2hhcGUSJAoFZHR5" + "cGUYASABKA4yFS50ZW5zb3Jib2FyZC5EYXRhVHlwZRIsCgVzaGFwZRgCIAEo" + "CzIdLnRlbnNvcmJvYXJkLlRlbnNvclNoYXBlUHJvdG9KBAgHEAhChwEKGG9y" + "Zy50ZW5zb3JmbG93LmZyYW1ld29ya0IOUmVzb3VyY2VIYW5kbGVQAVpWZ2l0" + "aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9nby9j" + "b3JlL2ZyYW1ld29yay9yZXNvdXJjZV9oYW5kbGVfZ29fcHJvdG/4AQFiBnBy" + "b3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[2]
			{
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(ResourceHandleProto), (MessageParser)(object)ResourceHandleProto.Parser, new string[6] { "Device", "Container", "Name", "HashCode", "MaybeTypeName", "DtypesAndShapes" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(ResourceHandleProto.Types.DtypeAndShape), (MessageParser)(object)ResourceHandleProto.Types.DtypeAndShape.Parser, new string[2] { "Dtype", "Shape" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				})
			}));
		}
	}
	public sealed class ResourceHandleProto : IMessage<ResourceHandleProto>, IMessage, IEquatable<ResourceHandleProto>, IDeepCloneable<ResourceHandleProto>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class DtypeAndShape : IMessage<DtypeAndShape>, IMessage, IEquatable<DtypeAndShape>, IDeepCloneable<DtypeAndShape>
			{
				private static readonly MessageParser<DtypeAndShape> _parser = new MessageParser<DtypeAndShape>((Func<DtypeAndShape>)(() => new DtypeAndShape()));

				private UnknownFieldSet _unknownFields;

				public const int DtypeFieldNumber = 1;

				private DataType dtype_;

				public const int ShapeFieldNumber = 2;

				private TensorShapeProto shape_;

				[DebuggerNonUserCode]
				public static MessageParser<DtypeAndShape> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => ResourceHandleProto.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public DataType Dtype
				{
					get
					{
						return dtype_;
					}
					set
					{
						dtype_ = value;
					}
				}

				[DebuggerNonUserCode]
				public TensorShapeProto Shape
				{
					get
					{
						return shape_;
					}
					set
					{
						shape_ = value;
					}
				}

				[DebuggerNonUserCode]
				public DtypeAndShape()
				{
				}

				[DebuggerNonUserCode]
				public DtypeAndShape(DtypeAndShape other)
					: this()
				{
					dtype_ = other.dtype_;
					shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public DtypeAndShape Clone()
				{
					return new DtypeAndShape(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as DtypeAndShape);
				}

				[DebuggerNonUserCode]
				public bool Equals(DtypeAndShape other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Dtype != other.Dtype)
					{
						return false;
					}
					if (!object.Equals(Shape, other.Shape))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Dtype != DataType.DtInvalid)
					{
						num ^= Dtype.GetHashCode();
					}
					if (shape_ != null)
					{
						num ^= Shape.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Dtype != DataType.DtInvalid)
					{
						output.WriteRawTag((byte)8);
						output.WriteEnum((int)Dtype);
					}
					if (shape_ != null)
					{
						output.WriteRawTag((byte)18);
						output.WriteMessage((IMessage)(object)Shape);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Dtype != DataType.DtInvalid)
					{
						num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
					}
					if (shape_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(DtypeAndShape other)
				{
					if (other == null)
					{
						return;
					}
					if (other.Dtype != DataType.DtInvalid)
					{
						Dtype = other.Dtype;
					}
					if (other.shape_ != null)
					{
						if (shape_ == null)
						{
							Shape = new TensorShapeProto();
						}
						Shape.MergeFrom(other.Shape);
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 8u:
							Dtype = (DataType)input.ReadEnum();
							break;
						case 18u:
							if (shape_ == null)
							{
								Shape = new TensorShapeProto();
							}
							input.ReadMessage((IMessage)(object)Shape);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<ResourceHandleProto> _parser = new MessageParser<ResourceHandleProto>((Func<ResourceHandleProto>)(() => new ResourceHandleProto()));

		private UnknownFieldSet _unknownFields;

		public const int DeviceFieldNumber = 1;

		private string device_ = "";

		public const int ContainerFieldNumber = 2;

		private string container_ = "";

		public const int NameFieldNumber = 3;

		private string name_ = "";

		public const int HashCodeFieldNumber = 4;

		private ulong hashCode_;

		public const int MaybeTypeNameFieldNumber = 5;

		private string maybeTypeName_ = "";

		public const int DtypesAndShapesFieldNumber = 6;

		private static readonly FieldCodec<Types.DtypeAndShape> _repeated_dtypesAndShapes_codec = FieldCodec.ForMessage<Types.DtypeAndShape>(50u, Types.DtypeAndShape.Parser);

		private readonly RepeatedField<Types.DtypeAndShape> dtypesAndShapes_ = new RepeatedField<Types.DtypeAndShape>();

		[DebuggerNonUserCode]
		public static MessageParser<ResourceHandleProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => ResourceHandleReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Device
		{
			get
			{
				return device_;
			}
			set
			{
				device_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Container
		{
			get
			{
				return container_;
			}
			set
			{
				container_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public ulong HashCode
		{
			get
			{
				return hashCode_;
			}
			set
			{
				hashCode_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string MaybeTypeName
		{
			get
			{
				return maybeTypeName_;
			}
			set
			{
				maybeTypeName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<Types.DtypeAndShape> DtypesAndShapes => dtypesAndShapes_;

		[DebuggerNonUserCode]
		public ResourceHandleProto()
		{
		}

		[DebuggerNonUserCode]
		public ResourceHandleProto(ResourceHandleProto other)
			: this()
		{
			device_ = other.device_;
			container_ = other.container_;
			name_ = other.name_;
			hashCode_ = other.hashCode_;
			maybeTypeName_ = other.maybeTypeName_;
			dtypesAndShapes_ = other.dtypesAndShapes_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ResourceHandleProto Clone()
		{
			return new ResourceHandleProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ResourceHandleProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(ResourceHandleProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Device != other.Device)
			{
				return false;
			}
			if (Container != other.Container)
			{
				return false;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (HashCode != other.HashCode)
			{
				return false;
			}
			if (MaybeTypeName != other.MaybeTypeName)
			{
				return false;
			}
			if (!dtypesAndShapes_.Equals(other.dtypesAndShapes_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Device.Length != 0)
			{
				num ^= Device.GetHashCode();
			}
			if (Container.Length != 0)
			{
				num ^= Container.GetHashCode();
			}
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (HashCode != 0L)
			{
				num ^= HashCode.GetHashCode();
			}
			if (MaybeTypeName.Length != 0)
			{
				num ^= MaybeTypeName.GetHashCode();
			}
			num ^= ((object)dtypesAndShapes_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Device.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Device);
			}
			if (Container.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(Container);
			}
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(Name);
			}
			if (HashCode != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteUInt64(HashCode);
			}
			if (MaybeTypeName.Length != 0)
			{
				output.WriteRawTag((byte)42);
				output.WriteString(MaybeTypeName);
			}
			dtypesAndShapes_.WriteTo(output, _repeated_dtypesAndShapes_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Device.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Device);
			}
			if (Container.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Container);
			}
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (HashCode != 0L)
			{
				num += 1 + CodedOutputStream.ComputeUInt64Size(HashCode);
			}
			if (MaybeTypeName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(MaybeTypeName);
			}
			num += dtypesAndShapes_.CalculateSize(_repeated_dtypesAndShapes_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ResourceHandleProto other)
		{
			if (other != null)
			{
				if (other.Device.Length != 0)
				{
					Device = other.Device;
				}
				if (other.Container.Length != 0)
				{
					Container = other.Container;
				}
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.HashCode != 0L)
				{
					HashCode = other.HashCode;
				}
				if (other.MaybeTypeName.Length != 0)
				{
					MaybeTypeName = other.MaybeTypeName;
				}
				dtypesAndShapes_.Add((IEnumerable<Types.DtypeAndShape>)other.dtypesAndShapes_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Device = input.ReadString();
					break;
				case 18u:
					Container = input.ReadString();
					break;
				case 26u:
					Name = input.ReadString();
					break;
				case 32u:
					HashCode = input.ReadUInt64();
					break;
				case 42u:
					MaybeTypeName = input.ReadString();
					break;
				case 50u:
					dtypesAndShapes_.AddEntriesFrom(input, _repeated_dtypesAndShapes_codec);
					break;
				}
			}
		}
	}
	public static class RewriterConfigReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static RewriterConfigReflection()
		{
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Expected O, but got Unknown
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Expected O, but got Unknown
			//IL_04a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a6: Expected O, but got Unknown
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ac: Expected O, but got Unknown
			//IL_04ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b6: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Ci50ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vcmV3cml0ZXJfY29uZmlnLnBy" + "b3RvEgt0ZW5zb3Jib2FyZBopdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL2F0" + "dHJfdmFsdWUucHJvdG8aLnRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by92ZXJp" + "Zmllcl9jb25maWcucHJvdG8iOwoTQXV0b1BhcmFsbGVsT3B0aW9ucxIOCgZl" + "bmFibGUYASABKAgSFAoMbnVtX3JlcGxpY2FzGAIgASgFIisKFlNjb3BlZEFs" + "bG9jYXRvck9wdGlvbnMSEQoJZW5hYmxlX29wGAEgAygJIu8UCg5SZXdyaXRl" + "ckNvbmZpZxJEChVjcHVfbGF5b3V0X2NvbnZlcnNpb24YMiABKA4yJS50ZW5z" + "b3Jib2FyZC5SZXdyaXRlckNvbmZpZy5DcHVMYXlvdXQSPAoQbGF5b3V0X29w" + "dGltaXplchgBIAEoDjIiLnRlbnNvcmJvYXJkLlJld3JpdGVyQ29uZmlnLlRv" + "Z2dsZRI8ChBjb25zdGFudF9mb2xkaW5nGAMgASgOMiIudGVuc29yYm9hcmQu" + "UmV3cml0ZXJDb25maWcuVG9nZ2xlEj4KEnNoYXBlX29wdGltaXphdGlvbhgN" + "IAEoDjIiLnRlbnNvcmJvYXJkLlJld3JpdGVyQ29uZmlnLlRvZ2dsZRI1Cgly" + "ZW1hcHBpbmcYDiABKA4yIi50ZW5zb3Jib2FyZC5SZXdyaXRlckNvbmZpZy5U" + "b2dnbGUSRwobY29tbW9uX3N1YmdyYXBoX2VsaW1pbmF0aW9uGBggASgOMiIu" + "dGVuc29yYm9hcmQuUmV3cml0ZXJDb25maWcuVG9nZ2xlEkMKF2FyaXRobWV0" + "aWNfb3B0aW1pemF0aW9uGAcgASgOMiIudGVuc29yYm9hcmQuUmV3cml0ZXJD" + "b25maWcuVG9nZ2xlEkMKF2RlcGVuZGVuY3lfb3B0aW1pemF0aW9uGAggASgO" + "MiIudGVuc29yYm9hcmQuUmV3cml0ZXJDb25maWcuVG9nZ2xlEj0KEWxvb3Bf" + "b3B0aW1pemF0aW9uGAkgASgOMiIudGVuc29yYm9hcmQuUmV3cml0ZXJDb25m" + "aWcuVG9nZ2xlEkEKFWZ1bmN0aW9uX29wdGltaXphdGlvbhgKIAEoDjIiLnRl" + "bnNvcmJvYXJkLlJld3JpdGVyQ29uZmlnLlRvZ2dsZRI6Cg5kZWJ1Z19zdHJp" + "cHBlchgLIAEoDjIiLnRlbnNvcmJvYXJkLlJld3JpdGVyQ29uZmlnLlRvZ2ds" + "ZRIdChVkaXNhYmxlX21vZGVsX3BydW5pbmcYAiABKAgSSQodc2NvcGVkX2Fs" + "bG9jYXRvcl9vcHRpbWl6YXRpb24YDyABKA4yIi50ZW5zb3Jib2FyZC5SZXdy" + "aXRlckNvbmZpZy5Ub2dnbGUSRAoYcGluX3RvX2hvc3Rfb3B0aW1pemF0aW9u" + "GBIgASgOMiIudGVuc29yYm9hcmQuUmV3cml0ZXJDb25maWcuVG9nZ2xlEkMK" + "F2ltcGxlbWVudGF0aW9uX3NlbGVjdG9yGBYgASgOMiIudGVuc29yYm9hcmQu" + "UmV3cml0ZXJDb25maWcuVG9nZ2xlEkAKFGF1dG9fbWl4ZWRfcHJlY2lzaW9u" + "GBcgASgOMiIudGVuc29yYm9hcmQuUmV3cml0ZXJDb25maWcuVG9nZ2xlEkQK" + "GGF1dG9fbWl4ZWRfcHJlY2lzaW9uX21rbBgZIAEoDjIiLnRlbnNvcmJvYXJk" + "LlJld3JpdGVyQ29uZmlnLlRvZ2dsZRJEChhhdXRvX21peGVkX3ByZWNpc2lv" + "bl9jcHUYHSABKA4yIi50ZW5zb3Jib2FyZC5SZXdyaXRlckNvbmZpZy5Ub2dn" + "bGUSHgoWZGlzYWJsZV9tZXRhX29wdGltaXplchgTIAEoCBJBChV1c2VfcGx1" + "Z2luX29wdGltaXplcnMYHCABKA4yIi50ZW5zb3Jib2FyZC5SZXdyaXRlckNv" + "bmZpZy5Ub2dnbGUSUAoZbWV0YV9vcHRpbWl6ZXJfaXRlcmF0aW9ucxgMIAEo" + "DjItLnRlbnNvcmJvYXJkLlJld3JpdGVyQ29uZmlnLk51bUl0ZXJhdGlvbnNU" + "eXBlEhcKD21pbl9ncmFwaF9ub2RlcxgRIAEoBRI7CjNleHBlcmltZW50YWxf" + "ZGlzYWJsZV9jb21wcmVzc2VkX3RlbnNvcl9vcHRpbWl6YXRpb24YGiABKAgS" + "OwozZXhwZXJpbWVudGFsX2Rpc2FibGVfZm9sZGluZ19xdWFudGl6YXRpb25f" + "ZW11bGF0aW9uGBsgASgIEkMKE21lbW9yeV9vcHRpbWl6YXRpb24YBCABKA4y" + "Ji50ZW5zb3Jib2FyZC5SZXdyaXRlckNvbmZpZy5NZW1PcHRUeXBlEi8KJ21l" + "bW9yeV9vcHRpbWl6ZXJfdGFyZ2V0X25vZGVfbmFtZV9zY29wZRgGIAEoCRIh" + "ChltZXRhX29wdGltaXplcl90aW1lb3V0X21zGBQgASgDEjcKDWF1dG9fcGFy" + "YWxsZWwYBSABKAsyIC50ZW5zb3Jib2FyZC5BdXRvUGFyYWxsZWxPcHRpb25z" + "EiAKGGZhaWxfb25fb3B0aW1pemVyX2Vycm9ycxgVIAEoCBJCChVzY29wZWRf" + "YWxsb2NhdG9yX29wdHMYECABKAsyIy50ZW5zb3Jib2FyZC5TY29wZWRBbGxv" + "Y2F0b3JPcHRpb25zEhIKCm9wdGltaXplcnMYZCADKAkSTAoRY3VzdG9tX29w" + "dGltaXplcnMYyAEgAygLMjAudGVuc29yYm9hcmQuUmV3cml0ZXJDb25maWcu" + "Q3VzdG9tR3JhcGhPcHRpbWl6ZXISRQofaW50ZXJfb3B0aW1pemVyX3Zlcmlm" + "aWVyX2NvbmZpZxisAiABKAsyGy50ZW5zb3Jib2FyZC5WZXJpZmllckNvbmZp" + "ZxJHCiFwb3N0X29wdGltaXphdGlvbl92ZXJpZmllcl9jb25maWcYrQIgASgL" + "MhsudGVuc29yYm9hcmQuVmVyaWZpZXJDb25maWcazAEKFEN1c3RvbUdyYXBo" + "T3B0aW1pemVyEgwKBG5hbWUYASABKAkSWQoNcGFyYW1ldGVyX21hcBgCIAMo" + "CzJCLnRlbnNvcmJvYXJkLlJld3JpdGVyQ29uZmlnLkN1c3RvbUdyYXBoT3B0" + "aW1pemVyLlBhcmFtZXRlck1hcEVudHJ5GksKEVBhcmFtZXRlck1hcEVudHJ5" + "EgsKA2tleRgBIAEoCRIlCgV2YWx1ZRgCIAEoCzIWLnRlbnNvcmJvYXJkLkF0" + "dHJWYWx1ZToCOAEiZAoGVG9nZ2xlEgsKB0RFRkFVTFQQABIGCgJPThABEgcK" + "A09GRhACEg4KCkFHR1JFU1NJVkUQAxIVChFFWFBFUklNRU5UQUxfTUxJUhAE" + "EhUKEUVYUEVSSU1FTlRBTF9CT1RIEAUiSQoJQ3B1TGF5b3V0EhgKFE5PX0NP" + "TlZFUlNJT05fT05fQ1BVEAASEAoMTkNIV19UT19OSFdDEAESEAoMTkhXQ19U" + "T19OQ0hXEAIiPAoRTnVtSXRlcmF0aW9uc1R5cGUSFQoRREVGQVVMVF9OVU1f" + "SVRFUlMQABIHCgNPTkUQARIHCgNUV08QAiKfAQoKTWVtT3B0VHlwZRITCg9E" + "RUZBVUxUX01FTV9PUFQQABIOCgpOT19NRU1fT1BUEAESCgoGTUFOVUFMEAIS" + "FwoTU1dBUFBJTkdfSEVVUklTVElDUxAEEhwKGFJFQ09NUFVUQVRJT05fSEVV" + "UklTVElDUxAFEhkKFVNDSEVEVUxJTkdfSEVVUklTVElDUxAGEg4KCkhFVVJJ" + "U1RJQ1MQA0KMAQoYb3JnLnRlbnNvcmZsb3cuZnJhbWV3b3JrQhRSZXdyaXRl" + "ckNvbmZpZ1Byb3Rvc1ABWlVnaXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29y" + "Zmxvdy90ZW5zb3JmbG93L2dvL2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJv" + "dG9zX2dvX3Byb3Rv+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[2]
			{
				AttrValueReflection.Descriptor,
				VerifierConfigReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[3]
			{
				new GeneratedClrTypeInfo(typeof(AutoParallelOptions), (MessageParser)(object)AutoParallelOptions.Parser, new string[2] { "Enable", "NumReplicas" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ScopedAllocatorOptions), (MessageParser)(object)ScopedAllocatorOptions.Parser, new string[1] { "EnableOp" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(RewriterConfig), (MessageParser)(object)RewriterConfig.Parser, new string[34]
				{
					"CpuLayoutConversion", "LayoutOptimizer", "ConstantFolding", "ShapeOptimization", "Remapping", "CommonSubgraphElimination", "ArithmeticOptimization", "DependencyOptimization", "LoopOptimization", "FunctionOptimization",
					"DebugStripper", "DisableModelPruning", "ScopedAllocatorOptimization", "PinToHostOptimization", "ImplementationSelector", "AutoMixedPrecision", "AutoMixedPrecisionMkl", "AutoMixedPrecisionCpu", "DisableMetaOptimizer", "UsePluginOptimizers",
					"MetaOptimizerIterations", "MinGraphNodes", "ExperimentalDisableCompressedTensorOptimization", "ExperimentalDisableFoldingQuantizationEmulation", "MemoryOptimization", "MemoryOptimizerTargetNodeNameScope", "MetaOptimizerTimeoutMs", "AutoParallel", "FailOnOptimizerErrors", "ScopedAllocatorOpts",
					"Optimizers", "CustomOptimizers", "InterOptimizerVerifierConfig", "PostOptimizationVerifierConfig"
				}, (string[])null, new Type[4]
				{
					typeof(RewriterConfig.Types.Toggle),
					typeof(RewriterConfig.Types.CpuLayout),
					typeof(RewriterConfig.Types.NumIterationsType),
					typeof(RewriterConfig.Types.MemOptType)
				}, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(RewriterConfig.Types.CustomGraphOptimizer), (MessageParser)(object)RewriterConfig.Types.CustomGraphOptimizer.Parser, new string[2] { "Name", "ParameterMap" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1])
				})
			}));
		}
	}
	public sealed class AutoParallelOptions : IMessage<AutoParallelOptions>, IMessage, IEquatable<AutoParallelOptions>, IDeepCloneable<AutoParallelOptions>
	{
		private static readonly MessageParser<AutoParallelOptions> _parser = new MessageParser<AutoParallelOptions>((Func<AutoParallelOptions>)(() => new AutoParallelOptions()));

		private UnknownFieldSet _unknownFields;

		public const int EnableFieldNumber = 1;

		private bool enable_;

		public const int NumReplicasFieldNumber = 2;

		private int numReplicas_;

		[DebuggerNonUserCode]
		public static MessageParser<AutoParallelOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => RewriterConfigReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public bool Enable
		{
			get
			{
				return enable_;
			}
			set
			{
				enable_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int NumReplicas
		{
			get
			{
				return numReplicas_;
			}
			set
			{
				numReplicas_ = value;
			}
		}

		[DebuggerNonUserCode]
		public AutoParallelOptions()
		{
		}

		[DebuggerNonUserCode]
		public AutoParallelOptions(AutoParallelOptions other)
			: this()
		{
			enable_ = other.enable_;
			numReplicas_ = other.numReplicas_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public AutoParallelOptions Clone()
		{
			return new AutoParallelOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as AutoParallelOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(AutoParallelOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Enable != other.Enable)
			{
				return false;
			}
			if (NumReplicas != other.NumReplicas)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Enable)
			{
				num ^= Enable.GetHashCode();
			}
			if (NumReplicas != 0)
			{
				num ^= NumReplicas.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Enable)
			{
				output.WriteRawTag((byte)8);
				output.WriteBool(Enable);
			}
			if (NumReplicas != 0)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt32(NumReplicas);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Enable)
			{
				num += 2;
			}
			if (NumReplicas != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(NumReplicas);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(AutoParallelOptions other)
		{
			if (other != null)
			{
				if (other.Enable)
				{
					Enable = other.Enable;
				}
				if (other.NumReplicas != 0)
				{
					NumReplicas = other.NumReplicas;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Enable = input.ReadBool();
					break;
				case 16u:
					NumReplicas = input.ReadInt32();
					break;
				}
			}
		}
	}
	public sealed class ScopedAllocatorOptions : IMessage<ScopedAllocatorOptions>, IMessage, IEquatable<ScopedAllocatorOptions>, IDeepCloneable<ScopedAllocatorOptions>
	{
		private static readonly MessageParser<ScopedAllocatorOptions> _parser = new MessageParser<ScopedAllocatorOptions>((Func<ScopedAllocatorOptions>)(() => new ScopedAllocatorOptions()));

		private UnknownFieldSet _unknownFields;

		public const int EnableOpFieldNumber = 1;

		private static readonly FieldCodec<string> _repeated_enableOp_codec = FieldCodec.ForString(10u);

		private readonly RepeatedField<string> enableOp_ = new RepeatedField<string>();

		[DebuggerNonUserCode]
		public static MessageParser<ScopedAllocatorOptions> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => RewriterConfigReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<string> EnableOp => enableOp_;

		[DebuggerNonUserCode]
		public ScopedAllocatorOptions()
		{
		}

		[DebuggerNonUserCode]
		public ScopedAllocatorOptions(ScopedAllocatorOptions other)
			: this()
		{
			enableOp_ = other.enableOp_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ScopedAllocatorOptions Clone()
		{
			return new ScopedAllocatorOptions(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ScopedAllocatorOptions);
		}

		[DebuggerNonUserCode]
		public bool Equals(ScopedAllocatorOptions other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!enableOp_.Equals(other.enableOp_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)enableOp_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			enableOp_.WriteTo(output, _repeated_enableOp_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += enableOp_.CalculateSize(_repeated_enableOp_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ScopedAllocatorOptions other)
		{
			if (other != null)
			{
				enableOp_.Add((IEnumerable<string>)other.enableOp_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					enableOp_.AddEntriesFrom(input, _repeated_enableOp_codec);
				}
			}
		}
	}
	public sealed class RewriterConfig : IMessage<RewriterConfig>, IMessage, IEquatable<RewriterConfig>, IDeepCloneable<RewriterConfig>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum Toggle
			{
				[OriginalName("DEFAULT")]
				Default,
				[OriginalName("ON")]
				On,
				[OriginalName("OFF")]
				Off,
				[OriginalName("AGGRESSIVE")]
				Aggressive,
				[OriginalName("EXPERIMENTAL_MLIR")]
				ExperimentalMlir,
				[OriginalName("EXPERIMENTAL_BOTH")]
				ExperimentalBoth
			}

			public enum CpuLayout
			{
				[OriginalName("NO_CONVERSION_ON_CPU")]
				NoConversionOnCpu,
				[OriginalName("NCHW_TO_NHWC")]
				NchwToNhwc,
				[OriginalName("NHWC_TO_NCHW")]
				NhwcToNchw
			}

			public enum NumIterationsType
			{
				[OriginalName("DEFAULT_NUM_ITERS")]
				DefaultNumIters,
				[OriginalName("ONE")]
				One,
				[OriginalName("TWO")]
				Two
			}

			public enum MemOptType
			{
				[OriginalName("DEFAULT_MEM_OPT")]
				DefaultMemOpt = 0,
				[OriginalName("NO_MEM_OPT")]
				NoMemOpt = 1,
				[OriginalName("MANUAL")]
				Manual = 2,
				[OriginalName("SWAPPING_HEURISTICS")]
				SwappingHeuristics = 4,
				[OriginalName("RECOMPUTATION_HEURISTICS")]
				RecomputationHeuristics = 5,
				[OriginalName("SCHEDULING_HEURISTICS")]
				SchedulingHeuristics = 6,
				[OriginalName("HEURISTICS")]
				Heuristics = 3
			}

			public sealed class CustomGraphOptimizer : IMessage<CustomGraphOptimizer>, IMessage, IEquatable<CustomGraphOptimizer>, IDeepCloneable<CustomGraphOptimizer>
			{
				private static readonly MessageParser<CustomGraphOptimizer> _parser = new MessageParser<CustomGraphOptimizer>((Func<CustomGraphOptimizer>)(() => new CustomGraphOptimizer()));

				private UnknownFieldSet _unknownFields;

				public const int NameFieldNumber = 1;

				private string name_ = "";

				public const int ParameterMapFieldNumber = 2;

				private static readonly Codec<string, AttrValue> _map_parameterMap_codec = new Codec<string, AttrValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<AttrValue>(18u, AttrValue.Parser), 18u);

				private readonly MapField<string, AttrValue> parameterMap_ = new MapField<string, AttrValue>();

				[DebuggerNonUserCode]
				public static MessageParser<CustomGraphOptimizer> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => RewriterConfig.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public MapField<string, AttrValue> ParameterMap => parameterMap_;

				[DebuggerNonUserCode]
				public CustomGraphOptimizer()
				{
				}

				[DebuggerNonUserCode]
				public CustomGraphOptimizer(CustomGraphOptimizer other)
					: this()
				{
					name_ = other.name_;
					parameterMap_ = other.parameterMap_.Clone();
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public CustomGraphOptimizer Clone()
				{
					return new CustomGraphOptimizer(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as CustomGraphOptimizer);
				}

				[DebuggerNonUserCode]
				public bool Equals(CustomGraphOptimizer other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Name != other.Name)
					{
						return false;
					}
					if (!ParameterMap.Equals(other.ParameterMap))
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					num ^= ((object)ParameterMap).GetHashCode();
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Name);
					}
					parameterMap_.WriteTo(output, _map_parameterMap_codec);
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					num += parameterMap_.CalculateSize(_map_parameterMap_codec);
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CustomGraphOptimizer other)
				{
					if (other != null)
					{
						if (other.Name.Length != 0)
						{
							Name = other.Name;
						}
						parameterMap_.Add((IDictionary<string, AttrValue>)other.parameterMap_);
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Name = input.ReadString();
							break;
						case 18u:
							parameterMap_.AddEntriesFrom(input, _map_parameterMap_codec);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<RewriterConfig> _parser = new MessageParser<RewriterConfig>((Func<RewriterConfig>)(() => new RewriterConfig()));

		private UnknownFieldSet _unknownFields;

		public const int CpuLayoutConversionFieldNumber = 50;

		private Types.CpuLayout cpuLayoutConversion_;

		public const int LayoutOptimizerFieldNumber = 1;

		private Types.Toggle layoutOptimizer_;

		public const int ConstantFoldingFieldNumber = 3;

		private Types.Toggle constantFolding_;

		public const int ShapeOptimizationFieldNumber = 13;

		private Types.Toggle shapeOptimization_;

		public const int RemappingFieldNumber = 14;

		private Types.Toggle remapping_;

		public const int CommonSubgraphEliminationFieldNumber = 24;

		private Types.Toggle commonSubgraphElimination_;

		public const int ArithmeticOptimizationFieldNumber = 7;

		private Types.Toggle arithmeticOptimization_;

		public const int DependencyOptimizationFieldNumber = 8;

		private Types.Toggle dependencyOptimization_;

		public const int LoopOptimizationFieldNumber = 9;

		private Types.Toggle loopOptimization_;

		public const int FunctionOptimizationFieldNumber = 10;

		private Types.Toggle functionOptimization_;

		public const int DebugStripperFieldNumber = 11;

		private Types.Toggle debugStripper_;

		public const int DisableModelPruningFieldNumber = 2;

		private bool disableModelPruning_;

		public const int ScopedAllocatorOptimizationFieldNumber = 15;

		private Types.Toggle scopedAllocatorOptimization_;

		public const int PinToHostOptimizationFieldNumber = 18;

		private Types.Toggle pinToHostOptimization_;

		public const int ImplementationSelectorFieldNumber = 22;

		private Types.Toggle implementationSelector_;

		public const int AutoMixedPrecisionFieldNumber = 23;

		private Types.Toggle autoMixedPrecision_;

		public const int AutoMixedPrecisionMklFieldNumber = 25;

		private Types.Toggle autoMixedPrecisionMkl_;

		public const int AutoMixedPrecisionCpuFieldNumber = 29;

		private Types.Toggle autoMixedPrecisionCpu_;

		public const int DisableMetaOptimizerFieldNumber = 19;

		private bool disableMetaOptimizer_;

		public const int UsePluginOptimizersFieldNumber = 28;

		private Types.Toggle usePluginOptimizers_;

		public const int MetaOptimizerIterationsFieldNumber = 12;

		private Types.NumIterationsType metaOptimizerIterations_;

		public const int MinGraphNodesFieldNumber = 17;

		private int minGraphNodes_;

		public const int ExperimentalDisableCompressedTensorOptimizationFieldNumber = 26;

		private bool experimentalDisableCompressedTensorOptimization_;

		public const int ExperimentalDisableFoldingQuantizationEmulationFieldNumber = 27;

		private bool experimentalDisableFoldingQuantizationEmulation_;

		public const int MemoryOptimizationFieldNumber = 4;

		private Types.MemOptType memoryOptimization_;

		public const int MemoryOptimizerTargetNodeNameScopeFieldNumber = 6;

		private string memoryOptimizerTargetNodeNameScope_ = "";

		public const int MetaOptimizerTimeoutMsFieldNumber = 20;

		private long metaOptimizerTimeoutMs_;

		public const int AutoParallelFieldNumber = 5;

		private AutoParallelOptions autoParallel_;

		public const int FailOnOptimizerErrorsFieldNumber = 21;

		private bool failOnOptimizerErrors_;

		public const int ScopedAllocatorOptsFieldNumber = 16;

		private ScopedAllocatorOptions scopedAllocatorOpts_;

		public const int OptimizersFieldNumber = 100;

		private static readonly FieldCodec<string> _repeated_optimizers_codec = FieldCodec.ForString(802u);

		private readonly RepeatedField<string> optimizers_ = new RepeatedField<string>();

		public const int CustomOptimizersFieldNumber = 200;

		private static readonly FieldCodec<Types.CustomGraphOptimizer> _repeated_customOptimizers_codec = FieldCodec.ForMessage<Types.CustomGraphOptimizer>(1602u, Types.CustomGraphOptimizer.Parser);

		private readonly RepeatedField<Types.CustomGraphOptimizer> customOptimizers_ = new RepeatedField<Types.CustomGraphOptimizer>();

		public const int InterOptimizerVerifierConfigFieldNumber = 300;

		private VerifierConfig interOptimizerVerifierConfig_;

		public const int PostOptimizationVerifierConfigFieldNumber = 301;

		private VerifierConfig postOptimizationVerifierConfig_;

		[DebuggerNonUserCode]
		public static MessageParser<RewriterConfig> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => RewriterConfigReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.CpuLayout CpuLayoutConversion
		{
			get
			{
				return cpuLayoutConversion_;
			}
			set
			{
				cpuLayoutConversion_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle LayoutOptimizer
		{
			get
			{
				return layoutOptimizer_;
			}
			set
			{
				layoutOptimizer_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle ConstantFolding
		{
			get
			{
				return constantFolding_;
			}
			set
			{
				constantFolding_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle ShapeOptimization
		{
			get
			{
				return shapeOptimization_;
			}
			set
			{
				shapeOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle Remapping
		{
			get
			{
				return remapping_;
			}
			set
			{
				remapping_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle CommonSubgraphElimination
		{
			get
			{
				return commonSubgraphElimination_;
			}
			set
			{
				commonSubgraphElimination_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle ArithmeticOptimization
		{
			get
			{
				return arithmeticOptimization_;
			}
			set
			{
				arithmeticOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle DependencyOptimization
		{
			get
			{
				return dependencyOptimization_;
			}
			set
			{
				dependencyOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle LoopOptimization
		{
			get
			{
				return loopOptimization_;
			}
			set
			{
				loopOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle FunctionOptimization
		{
			get
			{
				return functionOptimization_;
			}
			set
			{
				functionOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle DebugStripper
		{
			get
			{
				return debugStripper_;
			}
			set
			{
				debugStripper_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool DisableModelPruning
		{
			get
			{
				return disableModelPruning_;
			}
			set
			{
				disableModelPruning_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle ScopedAllocatorOptimization
		{
			get
			{
				return scopedAllocatorOptimization_;
			}
			set
			{
				scopedAllocatorOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle PinToHostOptimization
		{
			get
			{
				return pinToHostOptimization_;
			}
			set
			{
				pinToHostOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle ImplementationSelector
		{
			get
			{
				return implementationSelector_;
			}
			set
			{
				implementationSelector_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle AutoMixedPrecision
		{
			get
			{
				return autoMixedPrecision_;
			}
			set
			{
				autoMixedPrecision_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle AutoMixedPrecisionMkl
		{
			get
			{
				return autoMixedPrecisionMkl_;
			}
			set
			{
				autoMixedPrecisionMkl_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle AutoMixedPrecisionCpu
		{
			get
			{
				return autoMixedPrecisionCpu_;
			}
			set
			{
				autoMixedPrecisionCpu_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool DisableMetaOptimizer
		{
			get
			{
				return disableMetaOptimizer_;
			}
			set
			{
				disableMetaOptimizer_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle UsePluginOptimizers
		{
			get
			{
				return usePluginOptimizers_;
			}
			set
			{
				usePluginOptimizers_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.NumIterationsType MetaOptimizerIterations
		{
			get
			{
				return metaOptimizerIterations_;
			}
			set
			{
				metaOptimizerIterations_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int MinGraphNodes
		{
			get
			{
				return minGraphNodes_;
			}
			set
			{
				minGraphNodes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool ExperimentalDisableCompressedTensorOptimization
		{
			get
			{
				return experimentalDisableCompressedTensorOptimization_;
			}
			set
			{
				experimentalDisableCompressedTensorOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool ExperimentalDisableFoldingQuantizationEmulation
		{
			get
			{
				return experimentalDisableFoldingQuantizationEmulation_;
			}
			set
			{
				experimentalDisableFoldingQuantizationEmulation_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.MemOptType MemoryOptimization
		{
			get
			{
				return memoryOptimization_;
			}
			set
			{
				memoryOptimization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string MemoryOptimizerTargetNodeNameScope
		{
			get
			{
				return memoryOptimizerTargetNodeNameScope_;
			}
			set
			{
				memoryOptimizerTargetNodeNameScope_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long MetaOptimizerTimeoutMs
		{
			get
			{
				return metaOptimizerTimeoutMs_;
			}
			set
			{
				metaOptimizerTimeoutMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public AutoParallelOptions AutoParallel
		{
			get
			{
				return autoParallel_;
			}
			set
			{
				autoParallel_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool FailOnOptimizerErrors
		{
			get
			{
				return failOnOptimizerErrors_;
			}
			set
			{
				failOnOptimizerErrors_ = value;
			}
		}

		[DebuggerNonUserCode]
		public ScopedAllocatorOptions ScopedAllocatorOpts
		{
			get
			{
				return scopedAllocatorOpts_;
			}
			set
			{
				scopedAllocatorOpts_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> Optimizers => optimizers_;

		[DebuggerNonUserCode]
		public RepeatedField<Types.CustomGraphOptimizer> CustomOptimizers => customOptimizers_;

		[DebuggerNonUserCode]
		public VerifierConfig InterOptimizerVerifierConfig
		{
			get
			{
				return interOptimizerVerifierConfig_;
			}
			set
			{
				interOptimizerVerifierConfig_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VerifierConfig PostOptimizationVerifierConfig
		{
			get
			{
				return postOptimizationVerifierConfig_;
			}
			set
			{
				postOptimizationVerifierConfig_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RewriterConfig()
		{
		}

		[DebuggerNonUserCode]
		public RewriterConfig(RewriterConfig other)
			: this()
		{
			cpuLayoutConversion_ = other.cpuLayoutConversion_;
			layoutOptimizer_ = other.layoutOptimizer_;
			constantFolding_ = other.constantFolding_;
			shapeOptimization_ = other.shapeOptimization_;
			remapping_ = other.remapping_;
			commonSubgraphElimination_ = other.commonSubgraphElimination_;
			arithmeticOptimization_ = other.arithmeticOptimization_;
			dependencyOptimization_ = other.dependencyOptimization_;
			loopOptimization_ = other.loopOptimization_;
			functionOptimization_ = other.functionOptimization_;
			debugStripper_ = other.debugStripper_;
			disableModelPruning_ = other.disableModelPruning_;
			scopedAllocatorOptimization_ = other.scopedAllocatorOptimization_;
			pinToHostOptimization_ = other.pinToHostOptimization_;
			implementationSelector_ = other.implementationSelector_;
			autoMixedPrecision_ = other.autoMixedPrecision_;
			autoMixedPrecisionMkl_ = other.autoMixedPrecisionMkl_;
			autoMixedPrecisionCpu_ = other.autoMixedPrecisionCpu_;
			disableMetaOptimizer_ = other.disableMetaOptimizer_;
			usePluginOptimizers_ = other.usePluginOptimizers_;
			metaOptimizerIterations_ = other.metaOptimizerIterations_;
			minGraphNodes_ = other.minGraphNodes_;
			experimentalDisableCompressedTensorOptimization_ = other.experimentalDisableCompressedTensorOptimization_;
			experimentalDisableFoldingQuantizationEmulation_ = other.experimentalDisableFoldingQuantizationEmulation_;
			memoryOptimization_ = other.memoryOptimization_;
			memoryOptimizerTargetNodeNameScope_ = other.memoryOptimizerTargetNodeNameScope_;
			metaOptimizerTimeoutMs_ = other.metaOptimizerTimeoutMs_;
			autoParallel_ = ((other.autoParallel_ != null) ? other.autoParallel_.Clone() : null);
			failOnOptimizerErrors_ = other.failOnOptimizerErrors_;
			scopedAllocatorOpts_ = ((other.scopedAllocatorOpts_ != null) ? other.scopedAllocatorOpts_.Clone() : null);
			optimizers_ = other.optimizers_.Clone();
			customOptimizers_ = other.customOptimizers_.Clone();
			interOptimizerVerifierConfig_ = ((other.interOptimizerVerifierConfig_ != null) ? other.interOptimizerVerifierConfig_.Clone() : null);
			postOptimizationVerifierConfig_ = ((other.postOptimizationVerifierConfig_ != null) ? other.postOptimizationVerifierConfig_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RewriterConfig Clone()
		{
			return new RewriterConfig(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RewriterConfig);
		}

		[DebuggerNonUserCode]
		public bool Equals(RewriterConfig other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (CpuLayoutConversion != other.CpuLayoutConversion)
			{
				return false;
			}
			if (LayoutOptimizer != other.LayoutOptimizer)
			{
				return false;
			}
			if (ConstantFolding != other.ConstantFolding)
			{
				return false;
			}
			if (ShapeOptimization != other.ShapeOptimization)
			{
				return false;
			}
			if (Remapping != other.Remapping)
			{
				return false;
			}
			if (CommonSubgraphElimination != other.CommonSubgraphElimination)
			{
				return false;
			}
			if (ArithmeticOptimization != other.ArithmeticOptimization)
			{
				return false;
			}
			if (DependencyOptimization != other.DependencyOptimization)
			{
				return false;
			}
			if (LoopOptimization != other.LoopOptimization)
			{
				return false;
			}
			if (FunctionOptimization != other.FunctionOptimization)
			{
				return false;
			}
			if (DebugStripper != other.DebugStripper)
			{
				return false;
			}
			if (DisableModelPruning != other.DisableModelPruning)
			{
				return false;
			}
			if (ScopedAllocatorOptimization != other.ScopedAllocatorOptimization)
			{
				return false;
			}
			if (PinToHostOptimization != other.PinToHostOptimization)
			{
				return false;
			}
			if (ImplementationSelector != other.ImplementationSelector)
			{
				return false;
			}
			if (AutoMixedPrecision != other.AutoMixedPrecision)
			{
				return false;
			}
			if (AutoMixedPrecisionMkl != other.AutoMixedPrecisionMkl)
			{
				return false;
			}
			if (AutoMixedPrecisionCpu != other.AutoMixedPrecisionCpu)
			{
				return false;
			}
			if (DisableMetaOptimizer != other.DisableMetaOptimizer)
			{
				return false;
			}
			if (UsePluginOptimizers != other.UsePluginOptimizers)
			{
				return false;
			}
			if (MetaOptimizerIterations != other.MetaOptimizerIterations)
			{
				return false;
			}
			if (MinGraphNodes != other.MinGraphNodes)
			{
				return false;
			}
			if (ExperimentalDisableCompressedTensorOptimization != other.ExperimentalDisableCompressedTensorOptimization)
			{
				return false;
			}
			if (ExperimentalDisableFoldingQuantizationEmulation != other.ExperimentalDisableFoldingQuantizationEmulation)
			{
				return false;
			}
			if (MemoryOptimization != other.MemoryOptimization)
			{
				return false;
			}
			if (MemoryOptimizerTargetNodeNameScope != other.MemoryOptimizerTargetNodeNameScope)
			{
				return false;
			}
			if (MetaOptimizerTimeoutMs != other.MetaOptimizerTimeoutMs)
			{
				return false;
			}
			if (!object.Equals(AutoParallel, other.AutoParallel))
			{
				return false;
			}
			if (FailOnOptimizerErrors != other.FailOnOptimizerErrors)
			{
				return false;
			}
			if (!object.Equals(ScopedAllocatorOpts, other.ScopedAllocatorOpts))
			{
				return false;
			}
			if (!optimizers_.Equals(other.optimizers_))
			{
				return false;
			}
			if (!customOptimizers_.Equals(other.customOptimizers_))
			{
				return false;
			}
			if (!object.Equals(InterOptimizerVerifierConfig, other.InterOptimizerVerifierConfig))
			{
				return false;
			}
			if (!object.Equals(PostOptimizationVerifierConfig, other.PostOptimizationVerifierConfig))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (CpuLayoutConversion != Types.CpuLayout.NoConversionOnCpu)
			{
				num ^= CpuLayoutConversion.GetHashCode();
			}
			if (LayoutOptimizer != Types.Toggle.Default)
			{
				num ^= LayoutOptimizer.GetHashCode();
			}
			if (ConstantFolding != Types.Toggle.Default)
			{
				num ^= ConstantFolding.GetHashCode();
			}
			if (ShapeOptimization != Types.Toggle.Default)
			{
				num ^= ShapeOptimization.GetHashCode();
			}
			if (Remapping != Types.Toggle.Default)
			{
				num ^= Remapping.GetHashCode();
			}
			if (CommonSubgraphElimination != Types.Toggle.Default)
			{
				num ^= CommonSubgraphElimination.GetHashCode();
			}
			if (ArithmeticOptimization != Types.Toggle.Default)
			{
				num ^= ArithmeticOptimization.GetHashCode();
			}
			if (DependencyOptimization != Types.Toggle.Default)
			{
				num ^= DependencyOptimization.GetHashCode();
			}
			if (LoopOptimization != Types.Toggle.Default)
			{
				num ^= LoopOptimization.GetHashCode();
			}
			if (FunctionOptimization != Types.Toggle.Default)
			{
				num ^= FunctionOptimization.GetHashCode();
			}
			if (DebugStripper != Types.Toggle.Default)
			{
				num ^= DebugStripper.GetHashCode();
			}
			if (DisableModelPruning)
			{
				num ^= DisableModelPruning.GetHashCode();
			}
			if (ScopedAllocatorOptimization != Types.Toggle.Default)
			{
				num ^= ScopedAllocatorOptimization.GetHashCode();
			}
			if (PinToHostOptimization != Types.Toggle.Default)
			{
				num ^= PinToHostOptimization.GetHashCode();
			}
			if (ImplementationSelector != Types.Toggle.Default)
			{
				num ^= ImplementationSelector.GetHashCode();
			}
			if (AutoMixedPrecision != Types.Toggle.Default)
			{
				num ^= AutoMixedPrecision.GetHashCode();
			}
			if (AutoMixedPrecisionMkl != Types.Toggle.Default)
			{
				num ^= AutoMixedPrecisionMkl.GetHashCode();
			}
			if (AutoMixedPrecisionCpu != Types.Toggle.Default)
			{
				num ^= AutoMixedPrecisionCpu.GetHashCode();
			}
			if (DisableMetaOptimizer)
			{
				num ^= DisableMetaOptimizer.GetHashCode();
			}
			if (UsePluginOptimizers != Types.Toggle.Default)
			{
				num ^= UsePluginOptimizers.GetHashCode();
			}
			if (MetaOptimizerIterations != Types.NumIterationsType.DefaultNumIters)
			{
				num ^= MetaOptimizerIterations.GetHashCode();
			}
			if (MinGraphNodes != 0)
			{
				num ^= MinGraphNodes.GetHashCode();
			}
			if (ExperimentalDisableCompressedTensorOptimization)
			{
				num ^= ExperimentalDisableCompressedTensorOptimization.GetHashCode();
			}
			if (ExperimentalDisableFoldingQuantizationEmulation)
			{
				num ^= ExperimentalDisableFoldingQuantizationEmulation.GetHashCode();
			}
			if (MemoryOptimization != Types.MemOptType.DefaultMemOpt)
			{
				num ^= MemoryOptimization.GetHashCode();
			}
			if (MemoryOptimizerTargetNodeNameScope.Length != 0)
			{
				num ^= MemoryOptimizerTargetNodeNameScope.GetHashCode();
			}
			if (MetaOptimizerTimeoutMs != 0L)
			{
				num ^= MetaOptimizerTimeoutMs.GetHashCode();
			}
			if (autoParallel_ != null)
			{
				num ^= AutoParallel.GetHashCode();
			}
			if (FailOnOptimizerErrors)
			{
				num ^= FailOnOptimizerErrors.GetHashCode();
			}
			if (scopedAllocatorOpts_ != null)
			{
				num ^= ScopedAllocatorOpts.GetHashCode();
			}
			num ^= ((object)optimizers_).GetHashCode();
			num ^= ((object)customOptimizers_).GetHashCode();
			if (interOptimizerVerifierConfig_ != null)
			{
				num ^= InterOptimizerVerifierConfig.GetHashCode();
			}
			if (postOptimizationVerifierConfig_ != null)
			{
				num ^= PostOptimizationVerifierConfig.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (LayoutOptimizer != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)LayoutOptimizer);
			}
			if (DisableModelPruning)
			{
				output.WriteRawTag((byte)16);
				output.WriteBool(DisableModelPruning);
			}
			if (ConstantFolding != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)24);
				output.WriteEnum((int)ConstantFolding);
			}
			if (MemoryOptimization != Types.MemOptType.DefaultMemOpt)
			{
				output.WriteRawTag((byte)32);
				output.WriteEnum((int)MemoryOptimization);
			}
			if (autoParallel_ != null)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)AutoParallel);
			}
			if (MemoryOptimizerTargetNodeNameScope.Length != 0)
			{
				output.WriteRawTag((byte)50);
				output.WriteString(MemoryOptimizerTargetNodeNameScope);
			}
			if (ArithmeticOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)56);
				output.WriteEnum((int)ArithmeticOptimization);
			}
			if (DependencyOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)64);
				output.WriteEnum((int)DependencyOptimization);
			}
			if (LoopOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)72);
				output.WriteEnum((int)LoopOptimization);
			}
			if (FunctionOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)80);
				output.WriteEnum((int)FunctionOptimization);
			}
			if (DebugStripper != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)88);
				output.WriteEnum((int)DebugStripper);
			}
			if (MetaOptimizerIterations != Types.NumIterationsType.DefaultNumIters)
			{
				output.WriteRawTag((byte)96);
				output.WriteEnum((int)MetaOptimizerIterations);
			}
			if (ShapeOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)104);
				output.WriteEnum((int)ShapeOptimization);
			}
			if (Remapping != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)112);
				output.WriteEnum((int)Remapping);
			}
			if (ScopedAllocatorOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)120);
				output.WriteEnum((int)ScopedAllocatorOptimization);
			}
			if (scopedAllocatorOpts_ != null)
			{
				output.WriteRawTag((byte)130, (byte)1);
				output.WriteMessage((IMessage)(object)ScopedAllocatorOpts);
			}
			if (MinGraphNodes != 0)
			{
				output.WriteRawTag((byte)136, (byte)1);
				output.WriteInt32(MinGraphNodes);
			}
			if (PinToHostOptimization != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)144, (byte)1);
				output.WriteEnum((int)PinToHostOptimization);
			}
			if (DisableMetaOptimizer)
			{
				output.WriteRawTag((byte)152, (byte)1);
				output.WriteBool(DisableMetaOptimizer);
			}
			if (MetaOptimizerTimeoutMs != 0L)
			{
				output.WriteRawTag((byte)160, (byte)1);
				output.WriteInt64(MetaOptimizerTimeoutMs);
			}
			if (FailOnOptimizerErrors)
			{
				output.WriteRawTag((byte)168, (byte)1);
				output.WriteBool(FailOnOptimizerErrors);
			}
			if (ImplementationSelector != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)176, (byte)1);
				output.WriteEnum((int)ImplementationSelector);
			}
			if (AutoMixedPrecision != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)184, (byte)1);
				output.WriteEnum((int)AutoMixedPrecision);
			}
			if (CommonSubgraphElimination != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)192, (byte)1);
				output.WriteEnum((int)CommonSubgraphElimination);
			}
			if (AutoMixedPrecisionMkl != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)200, (byte)1);
				output.WriteEnum((int)AutoMixedPrecisionMkl);
			}
			if (ExperimentalDisableCompressedTensorOptimization)
			{
				output.WriteRawTag((byte)208, (byte)1);
				output.WriteBool(ExperimentalDisableCompressedTensorOptimization);
			}
			if (ExperimentalDisableFoldingQuantizationEmulation)
			{
				output.WriteRawTag((byte)216, (byte)1);
				output.WriteBool(ExperimentalDisableFoldingQuantizationEmulation);
			}
			if (UsePluginOptimizers != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)224, (byte)1);
				output.WriteEnum((int)UsePluginOptimizers);
			}
			if (AutoMixedPrecisionCpu != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)232, (byte)1);
				output.WriteEnum((int)AutoMixedPrecisionCpu);
			}
			if (CpuLayoutConversion != Types.CpuLayout.NoConversionOnCpu)
			{
				output.WriteRawTag((byte)144, (byte)3);
				output.WriteEnum((int)CpuLayoutConversion);
			}
			optimizers_.WriteTo(output, _repeated_optimizers_codec);
			customOptimizers_.WriteTo(output, _repeated_customOptimizers_codec);
			if (interOptimizerVerifierConfig_ != null)
			{
				output.WriteRawTag((byte)226, (byte)18);
				output.WriteMessage((IMessage)(object)InterOptimizerVerifierConfig);
			}
			if (postOptimizationVerifierConfig_ != null)
			{
				output.WriteRawTag((byte)234, (byte)18);
				output.WriteMessage((IMessage)(object)PostOptimizationVerifierConfig);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (CpuLayoutConversion != Types.CpuLayout.NoConversionOnCpu)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)CpuLayoutConversion);
			}
			if (LayoutOptimizer != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)LayoutOptimizer);
			}
			if (ConstantFolding != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)ConstantFolding);
			}
			if (ShapeOptimization != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)ShapeOptimization);
			}
			if (Remapping != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Remapping);
			}
			if (CommonSubgraphElimination != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)CommonSubgraphElimination);
			}
			if (ArithmeticOptimization != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)ArithmeticOptimization);
			}
			if (DependencyOptimization != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)DependencyOptimization);
			}
			if (LoopOptimization != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)LoopOptimization);
			}
			if (FunctionOptimization != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)FunctionOptimization);
			}
			if (DebugStripper != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)DebugStripper);
			}
			if (DisableModelPruning)
			{
				num += 2;
			}
			if (ScopedAllocatorOptimization != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)ScopedAllocatorOptimization);
			}
			if (PinToHostOptimization != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)PinToHostOptimization);
			}
			if (ImplementationSelector != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)ImplementationSelector);
			}
			if (AutoMixedPrecision != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)AutoMixedPrecision);
			}
			if (AutoMixedPrecisionMkl != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)AutoMixedPrecisionMkl);
			}
			if (AutoMixedPrecisionCpu != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)AutoMixedPrecisionCpu);
			}
			if (DisableMetaOptimizer)
			{
				num += 3;
			}
			if (UsePluginOptimizers != Types.Toggle.Default)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)UsePluginOptimizers);
			}
			if (MetaOptimizerIterations != Types.NumIterationsType.DefaultNumIters)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)MetaOptimizerIterations);
			}
			if (MinGraphNodes != 0)
			{
				num += 2 + CodedOutputStream.ComputeInt32Size(MinGraphNodes);
			}
			if (ExperimentalDisableCompressedTensorOptimization)
			{
				num += 3;
			}
			if (ExperimentalDisableFoldingQuantizationEmulation)
			{
				num += 3;
			}
			if (MemoryOptimization != Types.MemOptType.DefaultMemOpt)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)MemoryOptimization);
			}
			if (MemoryOptimizerTargetNodeNameScope.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(MemoryOptimizerTargetNodeNameScope);
			}
			if (MetaOptimizerTimeoutMs != 0L)
			{
				num += 2 + CodedOutputStream.ComputeInt64Size(MetaOptimizerTimeoutMs);
			}
			if (autoParallel_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)AutoParallel);
			}
			if (FailOnOptimizerErrors)
			{
				num += 3;
			}
			if (scopedAllocatorOpts_ != null)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ScopedAllocatorOpts);
			}
			num += optimizers_.CalculateSize(_repeated_optimizers_codec);
			num += customOptimizers_.CalculateSize(_repeated_customOptimizers_codec);
			if (interOptimizerVerifierConfig_ != null)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)InterOptimizerVerifierConfig);
			}
			if (postOptimizationVerifierConfig_ != null)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)PostOptimizationVerifierConfig);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RewriterConfig other)
		{
			if (other == null)
			{
				return;
			}
			if (other.CpuLayoutConversion != Types.CpuLayout.NoConversionOnCpu)
			{
				CpuLayoutConversion = other.CpuLayoutConversion;
			}
			if (other.LayoutOptimizer != Types.Toggle.Default)
			{
				LayoutOptimizer = other.LayoutOptimizer;
			}
			if (other.ConstantFolding != Types.Toggle.Default)
			{
				ConstantFolding = other.ConstantFolding;
			}
			if (other.ShapeOptimization != Types.Toggle.Default)
			{
				ShapeOptimization = other.ShapeOptimization;
			}
			if (other.Remapping != Types.Toggle.Default)
			{
				Remapping = other.Remapping;
			}
			if (other.CommonSubgraphElimination != Types.Toggle.Default)
			{
				CommonSubgraphElimination = other.CommonSubgraphElimination;
			}
			if (other.ArithmeticOptimization != Types.Toggle.Default)
			{
				ArithmeticOptimization = other.ArithmeticOptimization;
			}
			if (other.DependencyOptimization != Types.Toggle.Default)
			{
				DependencyOptimization = other.DependencyOptimization;
			}
			if (other.LoopOptimization != Types.Toggle.Default)
			{
				LoopOptimization = other.LoopOptimization;
			}
			if (other.FunctionOptimization != Types.Toggle.Default)
			{
				FunctionOptimization = other.FunctionOptimization;
			}
			if (other.DebugStripper != Types.Toggle.Default)
			{
				DebugStripper = other.DebugStripper;
			}
			if (other.DisableModelPruning)
			{
				DisableModelPruning = other.DisableModelPruning;
			}
			if (other.ScopedAllocatorOptimization != Types.Toggle.Default)
			{
				ScopedAllocatorOptimization = other.ScopedAllocatorOptimization;
			}
			if (other.PinToHostOptimization != Types.Toggle.Default)
			{
				PinToHostOptimization = other.PinToHostOptimization;
			}
			if (other.ImplementationSelector != Types.Toggle.Default)
			{
				ImplementationSelector = other.ImplementationSelector;
			}
			if (other.AutoMixedPrecision != Types.Toggle.Default)
			{
				AutoMixedPrecision = other.AutoMixedPrecision;
			}
			if (other.AutoMixedPrecisionMkl != Types.Toggle.Default)
			{
				AutoMixedPrecisionMkl = other.AutoMixedPrecisionMkl;
			}
			if (other.AutoMixedPrecisionCpu != Types.Toggle.Default)
			{
				AutoMixedPrecisionCpu = other.AutoMixedPrecisionCpu;
			}
			if (other.DisableMetaOptimizer)
			{
				DisableMetaOptimizer = other.DisableMetaOptimizer;
			}
			if (other.UsePluginOptimizers != Types.Toggle.Default)
			{
				UsePluginOptimizers = other.UsePluginOptimizers;
			}
			if (other.MetaOptimizerIterations != Types.NumIterationsType.DefaultNumIters)
			{
				MetaOptimizerIterations = other.MetaOptimizerIterations;
			}
			if (other.MinGraphNodes != 0)
			{
				MinGraphNodes = other.MinGraphNodes;
			}
			if (other.ExperimentalDisableCompressedTensorOptimization)
			{
				ExperimentalDisableCompressedTensorOptimization = other.ExperimentalDisableCompressedTensorOptimization;
			}
			if (other.ExperimentalDisableFoldingQuantizationEmulation)
			{
				ExperimentalDisableFoldingQuantizationEmulation = other.ExperimentalDisableFoldingQuantizationEmulation;
			}
			if (other.MemoryOptimization != Types.MemOptType.DefaultMemOpt)
			{
				MemoryOptimization = other.MemoryOptimization;
			}
			if (other.MemoryOptimizerTargetNodeNameScope.Length != 0)
			{
				MemoryOptimizerTargetNodeNameScope = other.MemoryOptimizerTargetNodeNameScope;
			}
			if (other.MetaOptimizerTimeoutMs != 0L)
			{
				MetaOptimizerTimeoutMs = other.MetaOptimizerTimeoutMs;
			}
			if (other.autoParallel_ != null)
			{
				if (autoParallel_ == null)
				{
					AutoParallel = new AutoParallelOptions();
				}
				AutoParallel.MergeFrom(other.AutoParallel);
			}
			if (other.FailOnOptimizerErrors)
			{
				FailOnOptimizerErrors = other.FailOnOptimizerErrors;
			}
			if (other.scopedAllocatorOpts_ != null)
			{
				if (scopedAllocatorOpts_ == null)
				{
					ScopedAllocatorOpts = new ScopedAllocatorOptions();
				}
				ScopedAllocatorOpts.MergeFrom(other.ScopedAllocatorOpts);
			}
			optimizers_.Add((IEnumerable<string>)other.optimizers_);
			customOptimizers_.Add((IEnumerable<Types.CustomGraphOptimizer>)other.customOptimizers_);
			if (other.interOptimizerVerifierConfig_ != null)
			{
				if (interOptimizerVerifierConfig_ == null)
				{
					InterOptimizerVerifierConfig = new VerifierConfig();
				}
				InterOptimizerVerifierConfig.MergeFrom(other.InterOptimizerVerifierConfig);
			}
			if (other.postOptimizationVerifierConfig_ != null)
			{
				if (postOptimizationVerifierConfig_ == null)
				{
					PostOptimizationVerifierConfig = new VerifierConfig();
				}
				PostOptimizationVerifierConfig.MergeFrom(other.PostOptimizationVerifierConfig);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					LayoutOptimizer = (Types.Toggle)input.ReadEnum();
					break;
				case 16u:
					DisableModelPruning = input.ReadBool();
					break;
				case 24u:
					ConstantFolding = (Types.Toggle)input.ReadEnum();
					break;
				case 32u:
					MemoryOptimization = (Types.MemOptType)input.ReadEnum();
					break;
				case 42u:
					if (autoParallel_ == null)
					{
						AutoParallel = new AutoParallelOptions();
					}
					input.ReadMessage((IMessage)(object)AutoParallel);
					break;
				case 50u:
					MemoryOptimizerTargetNodeNameScope = input.ReadString();
					break;
				case 56u:
					ArithmeticOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 64u:
					DependencyOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 72u:
					LoopOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 80u:
					FunctionOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 88u:
					DebugStripper = (Types.Toggle)input.ReadEnum();
					break;
				case 96u:
					MetaOptimizerIterations = (Types.NumIterationsType)input.ReadEnum();
					break;
				case 104u:
					ShapeOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 112u:
					Remapping = (Types.Toggle)input.ReadEnum();
					break;
				case 120u:
					ScopedAllocatorOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 130u:
					if (scopedAllocatorOpts_ == null)
					{
						ScopedAllocatorOpts = new ScopedAllocatorOptions();
					}
					input.ReadMessage((IMessage)(object)ScopedAllocatorOpts);
					break;
				case 136u:
					MinGraphNodes = input.ReadInt32();
					break;
				case 144u:
					PinToHostOptimization = (Types.Toggle)input.ReadEnum();
					break;
				case 152u:
					DisableMetaOptimizer = input.ReadBool();
					break;
				case 160u:
					MetaOptimizerTimeoutMs = input.ReadInt64();
					break;
				case 168u:
					FailOnOptimizerErrors = input.ReadBool();
					break;
				case 176u:
					ImplementationSelector = (Types.Toggle)input.ReadEnum();
					break;
				case 184u:
					AutoMixedPrecision = (Types.Toggle)input.ReadEnum();
					break;
				case 192u:
					CommonSubgraphElimination = (Types.Toggle)input.ReadEnum();
					break;
				case 200u:
					AutoMixedPrecisionMkl = (Types.Toggle)input.ReadEnum();
					break;
				case 208u:
					ExperimentalDisableCompressedTensorOptimization = input.ReadBool();
					break;
				case 216u:
					ExperimentalDisableFoldingQuantizationEmulation = input.ReadBool();
					break;
				case 224u:
					UsePluginOptimizers = (Types.Toggle)input.ReadEnum();
					break;
				case 232u:
					AutoMixedPrecisionCpu = (Types.Toggle)input.ReadEnum();
					break;
				case 400u:
					CpuLayoutConversion = (Types.CpuLayout)input.ReadEnum();
					break;
				case 802u:
					optimizers_.AddEntriesFrom(input, _repeated_optimizers_codec);
					break;
				case 1602u:
					customOptimizers_.AddEntriesFrom(input, _repeated_customOptimizers_codec);
					break;
				case 2402u:
					if (interOptimizerVerifierConfig_ == null)
					{
						InterOptimizerVerifierConfig = new VerifierConfig();
					}
					input.ReadMessage((IMessage)(object)InterOptimizerVerifierConfig);
					break;
				case 2410u:
					if (postOptimizationVerifierConfig_ == null)
					{
						PostOptimizationVerifierConfig = new VerifierConfig();
					}
					input.ReadMessage((IMessage)(object)PostOptimizationVerifierConfig);
					break;
				}
			}
		}
	}
	public static class SavedObjectGraphReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static SavedObjectGraphReflection()
		{
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_039e: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Expected O, but got Unknown
			//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Expected O, but got Unknown
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0406: Expected O, but got Unknown
			//IL_0431: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Expected O, but got Unknown
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Expected O, but got Unknown
			//IL_049b: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a1: Expected O, but got Unknown
			//IL_04dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e2: Expected O, but got Unknown
			//IL_0505: Unknown result type (might be due to invalid IL or missing references)
			//IL_050b: Expected O, but got Unknown
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_056d: Expected O, but got Unknown
			//IL_05bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Expected O, but got Unknown
			//IL_05e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Expected O, but got Unknown
			//IL_0617: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Expected O, but got Unknown
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0627: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CjF0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc2F2ZWRfb2JqZWN0X2dyYXBo" + "LnByb3RvEgt0ZW5zb3Jib2FyZBoZZ29vZ2xlL3Byb3RvYnVmL2FueS5wcm90" + "bxordGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3RlbnNvcl9zaGFwZS5wcm90" + "bxokdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3R5cGVzLnByb3RvGid0ZW5z" + "b3Jib2FyZC9jb21wYXQvcHJvdG8vdmFyaWFibGUucHJvdG8aJ3RlbnNvcmJv" + "YXJkL2NvbXBhdC9wcm90by92ZXJzaW9ucy5wcm90bxoldGVuc29yYm9hcmQv" + "Y29tcGF0L3Byb3RvL3N0cnVjdC5wcm90bxo1dGVuc29yYm9hcmQvY29tcGF0" + "L3Byb3RvL3RyYWNrYWJsZV9vYmplY3RfZ3JhcGgucHJvdG8i6wEKEFNhdmVk" + "T2JqZWN0R3JhcGgSJwoFbm9kZXMYASADKAsyGC50ZW5zb3Jib2FyZC5TYXZl" + "ZE9iamVjdBJQChJjb25jcmV0ZV9mdW5jdGlvbnMYAiADKAsyNC50ZW5zb3Ji" + "b2FyZC5TYXZlZE9iamVjdEdyYXBoLkNvbmNyZXRlRnVuY3Rpb25zRW50cnka" + "XAoWQ29uY3JldGVGdW5jdGlvbnNFbnRyeRILCgNrZXkYASABKAkSMQoFdmFs" + "dWUYAiABKAsyIi50ZW5zb3Jib2FyZC5TYXZlZENvbmNyZXRlRnVuY3Rpb246" + "AjgBIt0HCgtTYXZlZE9iamVjdBJTCghjaGlsZHJlbhgBIAMoCzJBLnRlbnNv" + "cmJvYXJkLlRyYWNrYWJsZU9iamVjdEdyYXBoLlRyYWNrYWJsZU9iamVjdC5P" + "YmplY3RSZWZlcmVuY2USVwoMZGVwZW5kZW5jaWVzGA8gAygLMkEudGVuc29y" + "Ym9hcmQuVHJhY2thYmxlT2JqZWN0R3JhcGguVHJhY2thYmxlT2JqZWN0Lk9i" + "amVjdFJlZmVyZW5jZRJfCg5zbG90X3ZhcmlhYmxlcxgDIAMoCzJHLnRlbnNv" + "cmJvYXJkLlRyYWNrYWJsZU9iamVjdEdyYXBoLlRyYWNrYWJsZU9iamVjdC5T" + "bG90VmFyaWFibGVSZWZlcmVuY2USMwoLdXNlcl9vYmplY3QYBCABKAsyHC50" + "ZW5zb3Jib2FyZC5TYXZlZFVzZXJPYmplY3RIABIoCgVhc3NldBgFIAEoCzIX" + "LnRlbnNvcmJvYXJkLlNhdmVkQXNzZXRIABIuCghmdW5jdGlvbhgGIAEoCzIa" + "LnRlbnNvcmJvYXJkLlNhdmVkRnVuY3Rpb25IABIuCgh2YXJpYWJsZRgHIAEo" + "CzIaLnRlbnNvcmJvYXJkLlNhdmVkVmFyaWFibGVIABJIChZiYXJlX2NvbmNy" + "ZXRlX2Z1bmN0aW9uGAggASgLMiYudGVuc29yYm9hcmQuU2F2ZWRCYXJlQ29u" + "Y3JldGVGdW5jdGlvbkgAEi4KCGNvbnN0YW50GAkgASgLMhoudGVuc29yYm9h" + "cmQuU2F2ZWRDb25zdGFudEgAEi4KCHJlc291cmNlGAogASgLMhoudGVuc29y" + "Ym9hcmQuU2F2ZWRSZXNvdXJjZUgAEjYKD2NhcHR1cmVkX3RlbnNvchgMIAEo" + "CzIbLnRlbnNvcmJvYXJkLkNhcHR1cmVkVGVuc29ySAASRwoQc2F2ZWFibGVf" + "b2JqZWN0cxgLIAMoCzItLnRlbnNvcmJvYXJkLlNhdmVkT2JqZWN0LlNhdmVh" + "YmxlT2JqZWN0c0VudHJ5EhcKD3JlZ2lzdGVyZWRfbmFtZRgNIAEoCRIzChVz" + "ZXJpYWxpemVkX3VzZXJfcHJvdG8YDiABKAsyFC5nb29nbGUucHJvdG9idWYu" + "QW55EhgKEHJlZ2lzdGVyZWRfc2F2ZXIYECABKAkaUwoUU2F2ZWFibGVPYmpl" + "Y3RzRW50cnkSCwoDa2V5GAEgASgJEioKBXZhbHVlGAIgASgLMhsudGVuc29y" + "Ym9hcmQuU2F2ZWFibGVPYmplY3Q6AjgBQgYKBGtpbmRKBAgCEANSCmF0dHJp" + "YnV0ZXMiZQoPU2F2ZWRVc2VyT2JqZWN0EhIKCmlkZW50aWZpZXIYASABKAkS" + "KAoHdmVyc2lvbhgCIAEoCzIXLnRlbnNvcmJvYXJkLlZlcnNpb25EZWYSFAoI" + "bWV0YWRhdGEYAyABKAlCAhgBIioKClNhdmVkQXNzZXQSHAoUYXNzZXRfZmls" + "ZV9kZWZfaW5kZXgYASABKAUiXQoNU2F2ZWRGdW5jdGlvbhIaChJjb25jcmV0" + "ZV9mdW5jdGlvbnMYASADKAkSMAoNZnVuY3Rpb25fc3BlYxgCIAEoCzIZLnRl" + "bnNvcmJvYXJkLkZ1bmN0aW9uU3BlYyI5Cg5DYXB0dXJlZFRlbnNvchIMCgRu" + "YW1lGAEgASgJEhkKEWNvbmNyZXRlX2Z1bmN0aW9uGAIgASgJIqoBChVTYXZl" + "ZENvbmNyZXRlRnVuY3Rpb24SFAoMYm91bmRfaW5wdXRzGAIgAygFEkMKHWNh" + "bm9uaWNhbGl6ZWRfaW5wdXRfc2lnbmF0dXJlGAMgASgLMhwudGVuc29yYm9h" + "cmQuU3RydWN0dXJlZFZhbHVlEjYKEG91dHB1dF9zaWduYXR1cmUYBCABKAsy" + "HC50ZW5zb3Jib2FyZC5TdHJ1Y3R1cmVkVmFsdWUirgEKGVNhdmVkQmFyZUNv" + "bmNyZXRlRnVuY3Rpb24SHgoWY29uY3JldGVfZnVuY3Rpb25fbmFtZRgBIAEo" + "CRIZChFhcmd1bWVudF9rZXl3b3JkcxgCIAMoCRIkChxhbGxvd2VkX3Bvc2l0" + "aW9uYWxfYXJndW1lbnRzGAMgASgDEjAKDWZ1bmN0aW9uX3NwZWMYBCABKAsy" + "GS50ZW5zb3Jib2FyZC5GdW5jdGlvblNwZWMiIgoNU2F2ZWRDb25zdGFudBIR" + "CglvcGVyYXRpb24YASABKAki3AIKDVNhdmVkVmFyaWFibGUSJAoFZHR5cGUY" + "ASABKA4yFS50ZW5zb3Jib2FyZC5EYXRhVHlwZRIsCgVzaGFwZRgCIAEoCzId" + "LnRlbnNvcmJvYXJkLlRlbnNvclNoYXBlUHJvdG8SEQoJdHJhaW5hYmxlGAMg" + "ASgIEj0KD3N5bmNocm9uaXphdGlvbhgEIAEoDjIkLnRlbnNvcmJvYXJkLlZh" + "cmlhYmxlU3luY2hyb25pemF0aW9uEjUKC2FnZ3JlZ2F0aW9uGAUgASgOMiAu" + "dGVuc29yYm9hcmQuVmFyaWFibGVBZ2dyZWdhdGlvbhIMCgRuYW1lGAYgASgJ" + "Eg4KBmRldmljZRgHIAEoCRJQCixleHBlcmltZW50YWxfZGlzdHJpYnV0ZWRf" + "dmFyaWFibGVfY29tcG9uZW50cxgIIAMoCzIaLnRlbnNvcmJvYXJkLlNhdmVk" + "VmFyaWFibGUi/gEKDEZ1bmN0aW9uU3BlYxIxCgtmdWxsYXJnc3BlYxgBIAEo" + "CzIcLnRlbnNvcmJvYXJkLlN0cnVjdHVyZWRWYWx1ZRIRCglpc19tZXRob2QY" + "AiABKAgSNQoPaW5wdXRfc2lnbmF0dXJlGAUgASgLMhwudGVuc29yYm9hcmQu" + "U3RydWN0dXJlZFZhbHVlEjkKC2ppdF9jb21waWxlGAYgASgOMiQudGVuc29y" + "Ym9hcmQuRnVuY3Rpb25TcGVjLkppdENvbXBpbGUiKgoKSml0Q29tcGlsZRIL" + "CgdERUZBVUxUEAASBgoCT04QARIHCgNPRkYQAkoECAMQBEoECAQQBSIfCg1T" + "YXZlZFJlc291cmNlEg4KBmRldmljZRgBIAEoCSJBCg5TYXZlYWJsZU9iamVj" + "dBIVCg1zYXZlX2Z1bmN0aW9uGAIgASgFEhgKEHJlc3RvcmVfZnVuY3Rpb24Y" + "AyABKAVCWlpVZ2l0aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVu" + "c29yZmxvdy9nby9jb3JlL3Byb3RvYnVmL2Zvcl9jb3JlX3Byb3Rvc19nb19w" + "cm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[7]
			{
				AnyReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor,
				VariableReflection.Descriptor,
				VersionsReflection.Descriptor,
				StructReflection.Descriptor,
				TrackableObjectGraphReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[13]
			{
				new GeneratedClrTypeInfo(typeof(SavedObjectGraph), (MessageParser)(object)SavedObjectGraph.Parser, new string[2] { "Nodes", "ConcreteFunctions" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(SavedObject), (MessageParser)(object)SavedObject.Parser, new string[15]
				{
					"Children", "Dependencies", "SlotVariables", "UserObject", "Asset", "Function", "Variable", "BareConcreteFunction", "Constant", "Resource",
					"CapturedTensor", "SaveableObjects", "RegisteredName", "SerializedUserProto", "RegisteredSaver"
				}, new string[1] { "Kind" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(SavedUserObject), (MessageParser)(object)SavedUserObject.Parser, new string[3] { "Identifier", "Version", "Metadata" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedAsset), (MessageParser)(object)SavedAsset.Parser, new string[1] { "AssetFileDefIndex" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedFunction), (MessageParser)(object)SavedFunction.Parser, new string[2] { "ConcreteFunctions", "FunctionSpec" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(CapturedTensor), (MessageParser)(object)CapturedTensor.Parser, new string[2] { "Name", "ConcreteFunction" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedConcreteFunction), (MessageParser)(object)SavedConcreteFunction.Parser, new string[3] { "BoundInputs", "CanonicalizedInputSignature", "OutputSignature" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedBareConcreteFunction), (MessageParser)(object)SavedBareConcreteFunction.Parser, new string[4] { "ConcreteFunctionName", "ArgumentKeywords", "AllowedPositionalArguments", "FunctionSpec" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedConstant), (MessageParser)(object)SavedConstant.Parser, new string[1] { "Operation" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedVariable), (MessageParser)(object)SavedVariable.Parser, new string[8] { "Dtype", "Shape", "Trainable", "Synchronization", "Aggregation", "Name", "Device", "ExperimentalDistributedVariableComponents" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(FunctionSpec), (MessageParser)(object)FunctionSpec.Parser, new string[4] { "Fullargspec", "IsMethod", "InputSignature", "JitCompile" }, (string[])null, new Type[1] { typeof(FunctionSpec.Types.JitCompile) }, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SavedResource), (MessageParser)(object)SavedResource.Parser, new string[1] { "Device" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SaveableObject), (MessageParser)(object)SaveableObject.Parser, new string[2] { "SaveFunction", "RestoreFunction" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class SavedObjectGraph : IMessage<SavedObjectGraph>, IMessage, IEquatable<SavedObjectGraph>, IDeepCloneable<SavedObjectGraph>
	{
		private static readonly MessageParser<SavedObjectGraph> _parser = new MessageParser<SavedObjectGraph>((Func<SavedObjectGraph>)(() => new SavedObjectGraph()));

		private UnknownFieldSet _unknownFields;

		public const int NodesFieldNumber = 1;

		private static readonly FieldCodec<SavedObject> _repeated_nodes_codec = FieldCodec.ForMessage<SavedObject>(10u, SavedObject.Parser);

		private readonly RepeatedField<SavedObject> nodes_ = new RepeatedField<SavedObject>();

		public const int ConcreteFunctionsFieldNumber = 2;

		private static readonly Codec<string, SavedConcreteFunction> _map_concreteFunctions_codec = new Codec<string, SavedConcreteFunction>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<SavedConcreteFunction>(18u, SavedConcreteFunction.Parser), 18u);

		private readonly MapField<string, SavedConcreteFunction> concreteFunctions_ = new MapField<string, SavedConcreteFunction>();

		[DebuggerNonUserCode]
		public static MessageParser<SavedObjectGraph> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<SavedObject> Nodes => nodes_;

		[DebuggerNonUserCode]
		public MapField<string, SavedConcreteFunction> ConcreteFunctions => concreteFunctions_;

		[DebuggerNonUserCode]
		public SavedObjectGraph()
		{
		}

		[DebuggerNonUserCode]
		public SavedObjectGraph(SavedObjectGraph other)
			: this()
		{
			nodes_ = other.nodes_.Clone();
			concreteFunctions_ = other.concreteFunctions_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedObjectGraph Clone()
		{
			return new SavedObjectGraph(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedObjectGraph);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedObjectGraph other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!nodes_.Equals(other.nodes_))
			{
				return false;
			}
			if (!ConcreteFunctions.Equals(other.ConcreteFunctions))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)nodes_).GetHashCode();
			num ^= ((object)ConcreteFunctions).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			nodes_.WriteTo(output, _repeated_nodes_codec);
			concreteFunctions_.WriteTo(output, _map_concreteFunctions_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += nodes_.CalculateSize(_repeated_nodes_codec);
			num += concreteFunctions_.CalculateSize(_map_concreteFunctions_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedObjectGraph other)
		{
			if (other != null)
			{
				nodes_.Add((IEnumerable<SavedObject>)other.nodes_);
				concreteFunctions_.Add((IDictionary<string, SavedConcreteFunction>)other.concreteFunctions_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					nodes_.AddEntriesFrom(input, _repeated_nodes_codec);
					break;
				case 18u:
					concreteFunctions_.AddEntriesFrom(input, _map_concreteFunctions_codec);
					break;
				}
			}
		}
	}
	public sealed class SavedObject : IMessage<SavedObject>, IMessage, IEquatable<SavedObject>, IDeepCloneable<SavedObject>
	{
		public enum KindOneofCase
		{
			None = 0,
			UserObject = 4,
			Asset = 5,
			Function = 6,
			Variable = 7,
			BareConcreteFunction = 8,
			Constant = 9,
			Resource = 10,
			CapturedTensor = 12
		}

		private static readonly MessageParser<SavedObject> _parser = new MessageParser<SavedObject>((Func<SavedObject>)(() => new SavedObject()));

		private UnknownFieldSet _unknownFields;

		public const int ChildrenFieldNumber = 1;

		private static readonly FieldCodec<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> _repeated_children_codec = FieldCodec.ForMessage<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>(10u, TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference.Parser);

		private readonly RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> children_ = new RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>();

		public const int DependenciesFieldNumber = 15;

		private static readonly FieldCodec<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> _repeated_dependencies_codec = FieldCodec.ForMessage<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>(122u, TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference.Parser);

		private readonly RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> dependencies_ = new RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>();

		public const int SlotVariablesFieldNumber = 3;

		private static readonly FieldCodec<TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference> _repeated_slotVariables_codec = FieldCodec.ForMessage<TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference>(26u, TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference.Parser);

		private readonly RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference> slotVariables_ = new RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference>();

		public const int UserObjectFieldNumber = 4;

		public const int AssetFieldNumber = 5;

		public const int FunctionFieldNumber = 6;

		public const int VariableFieldNumber = 7;

		public const int BareConcreteFunctionFieldNumber = 8;

		public const int ConstantFieldNumber = 9;

		public const int ResourceFieldNumber = 10;

		public const int CapturedTensorFieldNumber = 12;

		public const int SaveableObjectsFieldNumber = 11;

		private static readonly Codec<string, SaveableObject> _map_saveableObjects_codec = new Codec<string, SaveableObject>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<SaveableObject>(18u, SaveableObject.Parser), 90u);

		private readonly MapField<string, SaveableObject> saveableObjects_ = new MapField<string, SaveableObject>();

		public const int RegisteredNameFieldNumber = 13;

		private string registeredName_ = "";

		public const int SerializedUserProtoFieldNumber = 14;

		private Any serializedUserProto_;

		public const int RegisteredSaverFieldNumber = 16;

		private string registeredSaver_ = "";

		private object kind_;

		private KindOneofCase kindCase_;

		[DebuggerNonUserCode]
		public static MessageParser<SavedObject> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> Children => children_;

		[DebuggerNonUserCode]
		public RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference> Dependencies => dependencies_;

		[DebuggerNonUserCode]
		public RepeatedField<TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference> SlotVariables => slotVariables_;

		[DebuggerNonUserCode]
		public SavedUserObject UserObject
		{
			get
			{
				if (kindCase_ != KindOneofCase.UserObject)
				{
					return null;
				}
				return (SavedUserObject)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.UserObject : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SavedAsset Asset
		{
			get
			{
				if (kindCase_ != KindOneofCase.Asset)
				{
					return null;
				}
				return (SavedAsset)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.Asset : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SavedFunction Function
		{
			get
			{
				if (kindCase_ != KindOneofCase.Function)
				{
					return null;
				}
				return (SavedFunction)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.Function : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SavedVariable Variable
		{
			get
			{
				if (kindCase_ != KindOneofCase.Variable)
				{
					return null;
				}
				return (SavedVariable)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.Variable : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SavedBareConcreteFunction BareConcreteFunction
		{
			get
			{
				if (kindCase_ != KindOneofCase.BareConcreteFunction)
				{
					return null;
				}
				return (SavedBareConcreteFunction)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.BareConcreteFunction : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SavedConstant Constant
		{
			get
			{
				if (kindCase_ != KindOneofCase.Constant)
				{
					return null;
				}
				return (SavedConstant)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.Constant : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public SavedResource Resource
		{
			get
			{
				if (kindCase_ != KindOneofCase.Resource)
				{
					return null;
				}
				return (SavedResource)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.Resource : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public CapturedTensor CapturedTensor
		{
			get
			{
				if (kindCase_ != KindOneofCase.CapturedTensor)
				{
					return null;
				}
				return (CapturedTensor)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.CapturedTensor : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, SaveableObject> SaveableObjects => saveableObjects_;

		[DebuggerNonUserCode]
		public string RegisteredName
		{
			get
			{
				return registeredName_;
			}
			set
			{
				registeredName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public Any SerializedUserProto
		{
			get
			{
				return serializedUserProto_;
			}
			set
			{
				serializedUserProto_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string RegisteredSaver
		{
			get
			{
				return registeredSaver_;
			}
			set
			{
				registeredSaver_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public KindOneofCase KindCase => kindCase_;

		[DebuggerNonUserCode]
		public SavedObject()
		{
		}

		[DebuggerNonUserCode]
		public SavedObject(SavedObject other)
			: this()
		{
			children_ = other.children_.Clone();
			dependencies_ = other.dependencies_.Clone();
			slotVariables_ = other.slotVariables_.Clone();
			saveableObjects_ = other.saveableObjects_.Clone();
			registeredName_ = other.registeredName_;
			serializedUserProto_ = ((other.serializedUserProto_ != null) ? other.serializedUserProto_.Clone() : null);
			registeredSaver_ = other.registeredSaver_;
			switch (other.KindCase)
			{
			case KindOneofCase.UserObject:
				UserObject = other.UserObject.Clone();
				break;
			case KindOneofCase.Asset:
				Asset = other.Asset.Clone();
				break;
			case KindOneofCase.Function:
				Function = other.Function.Clone();
				break;
			case KindOneofCase.Variable:
				Variable = other.Variable.Clone();
				break;
			case KindOneofCase.BareConcreteFunction:
				BareConcreteFunction = other.BareConcreteFunction.Clone();
				break;
			case KindOneofCase.Constant:
				Constant = other.Constant.Clone();
				break;
			case KindOneofCase.Resource:
				Resource = other.Resource.Clone();
				break;
			case KindOneofCase.CapturedTensor:
				CapturedTensor = other.CapturedTensor.Clone();
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedObject Clone()
		{
			return new SavedObject(this);
		}

		[DebuggerNonUserCode]
		public void ClearKind()
		{
			kindCase_ = KindOneofCase.None;
			kind_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedObject);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedObject other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!children_.Equals(other.children_))
			{
				return false;
			}
			if (!dependencies_.Equals(other.dependencies_))
			{
				return false;
			}
			if (!slotVariables_.Equals(other.slotVariables_))
			{
				return false;
			}
			if (!object.Equals(UserObject, other.UserObject))
			{
				return false;
			}
			if (!object.Equals(Asset, other.Asset))
			{
				return false;
			}
			if (!object.Equals(Function, other.Function))
			{
				return false;
			}
			if (!object.Equals(Variable, other.Variable))
			{
				return false;
			}
			if (!object.Equals(BareConcreteFunction, other.BareConcreteFunction))
			{
				return false;
			}
			if (!object.Equals(Constant, other.Constant))
			{
				return false;
			}
			if (!object.Equals(Resource, other.Resource))
			{
				return false;
			}
			if (!object.Equals(CapturedTensor, other.CapturedTensor))
			{
				return false;
			}
			if (!SaveableObjects.Equals(other.SaveableObjects))
			{
				return false;
			}
			if (RegisteredName != other.RegisteredName)
			{
				return false;
			}
			if (!object.Equals(SerializedUserProto, other.SerializedUserProto))
			{
				return false;
			}
			if (RegisteredSaver != other.RegisteredSaver)
			{
				return false;
			}
			if (KindCase != other.KindCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)children_).GetHashCode();
			num ^= ((object)dependencies_).GetHashCode();
			num ^= ((object)slotVariables_).GetHashCode();
			if (kindCase_ == KindOneofCase.UserObject)
			{
				num ^= UserObject.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Asset)
			{
				num ^= Asset.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Function)
			{
				num ^= Function.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Variable)
			{
				num ^= Variable.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.BareConcreteFunction)
			{
				num ^= BareConcreteFunction.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Constant)
			{
				num ^= Constant.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Resource)
			{
				num ^= Resource.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.CapturedTensor)
			{
				num ^= CapturedTensor.GetHashCode();
			}
			num ^= ((object)SaveableObjects).GetHashCode();
			if (RegisteredName.Length != 0)
			{
				num ^= RegisteredName.GetHashCode();
			}
			if (serializedUserProto_ != null)
			{
				num ^= ((object)SerializedUserProto).GetHashCode();
			}
			if (RegisteredSaver.Length != 0)
			{
				num ^= RegisteredSaver.GetHashCode();
			}
			num ^= (int)kindCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			children_.WriteTo(output, _repeated_children_codec);
			slotVariables_.WriteTo(output, _repeated_slotVariables_codec);
			if (kindCase_ == KindOneofCase.UserObject)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)UserObject);
			}
			if (kindCase_ == KindOneofCase.Asset)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)Asset);
			}
			if (kindCase_ == KindOneofCase.Function)
			{
				output.WriteRawTag((byte)50);
				output.WriteMessage((IMessage)(object)Function);
			}
			if (kindCase_ == KindOneofCase.Variable)
			{
				output.WriteRawTag((byte)58);
				output.WriteMessage((IMessage)(object)Variable);
			}
			if (kindCase_ == KindOneofCase.BareConcreteFunction)
			{
				output.WriteRawTag((byte)66);
				output.WriteMessage((IMessage)(object)BareConcreteFunction);
			}
			if (kindCase_ == KindOneofCase.Constant)
			{
				output.WriteRawTag((byte)74);
				output.WriteMessage((IMessage)(object)Constant);
			}
			if (kindCase_ == KindOneofCase.Resource)
			{
				output.WriteRawTag((byte)82);
				output.WriteMessage((IMessage)(object)Resource);
			}
			saveableObjects_.WriteTo(output, _map_saveableObjects_codec);
			if (kindCase_ == KindOneofCase.CapturedTensor)
			{
				output.WriteRawTag((byte)98);
				output.WriteMessage((IMessage)(object)CapturedTensor);
			}
			if (RegisteredName.Length != 0)
			{
				output.WriteRawTag((byte)106);
				output.WriteString(RegisteredName);
			}
			if (serializedUserProto_ != null)
			{
				output.WriteRawTag((byte)114);
				output.WriteMessage((IMessage)(object)SerializedUserProto);
			}
			dependencies_.WriteTo(output, _repeated_dependencies_codec);
			if (RegisteredSaver.Length != 0)
			{
				output.WriteRawTag((byte)130, (byte)1);
				output.WriteString(RegisteredSaver);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += children_.CalculateSize(_repeated_children_codec);
			num += dependencies_.CalculateSize(_repeated_dependencies_codec);
			num += slotVariables_.CalculateSize(_repeated_slotVariables_codec);
			if (kindCase_ == KindOneofCase.UserObject)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)UserObject);
			}
			if (kindCase_ == KindOneofCase.Asset)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Asset);
			}
			if (kindCase_ == KindOneofCase.Function)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Function);
			}
			if (kindCase_ == KindOneofCase.Variable)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Variable);
			}
			if (kindCase_ == KindOneofCase.BareConcreteFunction)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)BareConcreteFunction);
			}
			if (kindCase_ == KindOneofCase.Constant)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Constant);
			}
			if (kindCase_ == KindOneofCase.Resource)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Resource);
			}
			if (kindCase_ == KindOneofCase.CapturedTensor)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CapturedTensor);
			}
			num += saveableObjects_.CalculateSize(_map_saveableObjects_codec);
			if (RegisteredName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(RegisteredName);
			}
			if (serializedUserProto_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)SerializedUserProto);
			}
			if (RegisteredSaver.Length != 0)
			{
				num += 2 + CodedOutputStream.ComputeStringSize(RegisteredSaver);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedObject other)
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (other == null)
			{
				return;
			}
			children_.Add((IEnumerable<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>)other.children_);
			dependencies_.Add((IEnumerable<TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference>)other.dependencies_);
			slotVariables_.Add((IEnumerable<TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference>)other.slotVariables_);
			saveableObjects_.Add((IDictionary<string, SaveableObject>)other.saveableObjects_);
			if (other.RegisteredName.Length != 0)
			{
				RegisteredName = other.RegisteredName;
			}
			if (other.serializedUserProto_ != null)
			{
				if (serializedUserProto_ == null)
				{
					SerializedUserProto = new Any();
				}
				SerializedUserProto.MergeFrom(other.SerializedUserProto);
			}
			if (other.RegisteredSaver.Length != 0)
			{
				RegisteredSaver = other.RegisteredSaver;
			}
			switch (other.KindCase)
			{
			case KindOneofCase.UserObject:
				if (UserObject == null)
				{
					UserObject = new SavedUserObject();
				}
				UserObject.MergeFrom(other.UserObject);
				break;
			case KindOneofCase.Asset:
				if (Asset == null)
				{
					Asset = new SavedAsset();
				}
				Asset.MergeFrom(other.Asset);
				break;
			case KindOneofCase.Function:
				if (Function == null)
				{
					Function = new SavedFunction();
				}
				Function.MergeFrom(other.Function);
				break;
			case KindOneofCase.Variable:
				if (Variable == null)
				{
					Variable = new SavedVariable();
				}
				Variable.MergeFrom(other.Variable);
				break;
			case KindOneofCase.BareConcreteFunction:
				if (BareConcreteFunction == null)
				{
					BareConcreteFunction = new SavedBareConcreteFunction();
				}
				BareConcreteFunction.MergeFrom(other.BareConcreteFunction);
				break;
			case KindOneofCase.Constant:
				if (Constant == null)
				{
					Constant = new SavedConstant();
				}
				Constant.MergeFrom(other.Constant);
				break;
			case KindOneofCase.Resource:
				if (Resource == null)
				{
					Resource = new SavedResource();
				}
				Resource.MergeFrom(other.Resource);
				break;
			case KindOneofCase.CapturedTensor:
				if (CapturedTensor == null)
				{
					CapturedTensor = new CapturedTensor();
				}
				CapturedTensor.MergeFrom(other.CapturedTensor);
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			//IL_029e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					children_.AddEntriesFrom(input, _repeated_children_codec);
					break;
				case 26u:
					slotVariables_.AddEntriesFrom(input, _repeated_slotVariables_codec);
					break;
				case 34u:
				{
					SavedUserObject savedUserObject = new SavedUserObject();
					if (kindCase_ == KindOneofCase.UserObject)
					{
						savedUserObject.MergeFrom(UserObject);
					}
					input.ReadMessage((IMessage)(object)savedUserObject);
					UserObject = savedUserObject;
					break;
				}
				case 42u:
				{
					SavedAsset savedAsset = new SavedAsset();
					if (kindCase_ == KindOneofCase.Asset)
					{
						savedAsset.MergeFrom(Asset);
					}
					input.ReadMessage((IMessage)(object)savedAsset);
					Asset = savedAsset;
					break;
				}
				case 50u:
				{
					SavedFunction savedFunction = new SavedFunction();
					if (kindCase_ == KindOneofCase.Function)
					{
						savedFunction.MergeFrom(Function);
					}
					input.ReadMessage((IMessage)(object)savedFunction);
					Function = savedFunction;
					break;
				}
				case 58u:
				{
					SavedVariable savedVariable = new SavedVariable();
					if (kindCase_ == KindOneofCase.Variable)
					{
						savedVariable.MergeFrom(Variable);
					}
					input.ReadMessage((IMessage)(object)savedVariable);
					Variable = savedVariable;
					break;
				}
				case 66u:
				{
					SavedBareConcreteFunction savedBareConcreteFunction = new SavedBareConcreteFunction();
					if (kindCase_ == KindOneofCase.BareConcreteFunction)
					{
						savedBareConcreteFunction.MergeFrom(BareConcreteFunction);
					}
					input.ReadMessage((IMessage)(object)savedBareConcreteFunction);
					BareConcreteFunction = savedBareConcreteFunction;
					break;
				}
				case 74u:
				{
					SavedConstant savedConstant = new SavedConstant();
					if (kindCase_ == KindOneofCase.Constant)
					{
						savedConstant.MergeFrom(Constant);
					}
					input.ReadMessage((IMessage)(object)savedConstant);
					Constant = savedConstant;
					break;
				}
				case 82u:
				{
					SavedResource savedResource = new SavedResource();
					if (kindCase_ == KindOneofCase.Resource)
					{
						savedResource.MergeFrom(Resource);
					}
					input.ReadMessage((IMessage)(object)savedResource);
					Resource = savedResource;
					break;
				}
				case 90u:
					saveableObjects_.AddEntriesFrom(input, _map_saveableObjects_codec);
					break;
				case 98u:
				{
					CapturedTensor capturedTensor = new CapturedTensor();
					if (kindCase_ == KindOneofCase.CapturedTensor)
					{
						capturedTensor.MergeFrom(CapturedTensor);
					}
					input.ReadMessage((IMessage)(object)capturedTensor);
					CapturedTensor = capturedTensor;
					break;
				}
				case 106u:
					RegisteredName = input.ReadString();
					break;
				case 114u:
					if (serializedUserProto_ == null)
					{
						SerializedUserProto = new Any();
					}
					input.ReadMessage((IMessage)(object)SerializedUserProto);
					break;
				case 122u:
					dependencies_.AddEntriesFrom(input, _repeated_dependencies_codec);
					break;
				case 130u:
					RegisteredSaver = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class SavedUserObject : IMessage<SavedUserObject>, IMessage, IEquatable<SavedUserObject>, IDeepCloneable<SavedUserObject>
	{
		private static readonly MessageParser<SavedUserObject> _parser = new MessageParser<SavedUserObject>((Func<SavedUserObject>)(() => new SavedUserObject()));

		private UnknownFieldSet _unknownFields;

		public const int IdentifierFieldNumber = 1;

		private string identifier_ = "";

		public const int VersionFieldNumber = 2;

		private VersionDef version_;

		public const int MetadataFieldNumber = 3;

		private string metadata_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<SavedUserObject> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Identifier
		{
			get
			{
				return identifier_;
			}
			set
			{
				identifier_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public VersionDef Version
		{
			get
			{
				return version_;
			}
			set
			{
				version_ = value;
			}
		}

		[Obsolete]
		[DebuggerNonUserCode]
		public string Metadata
		{
			get
			{
				return metadata_;
			}
			set
			{
				metadata_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SavedUserObject()
		{
		}

		[DebuggerNonUserCode]
		public SavedUserObject(SavedUserObject other)
			: this()
		{
			identifier_ = other.identifier_;
			version_ = ((other.version_ != null) ? other.version_.Clone() : null);
			metadata_ = other.metadata_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedUserObject Clone()
		{
			return new SavedUserObject(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedUserObject);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedUserObject other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Identifier != other.Identifier)
			{
				return false;
			}
			if (!object.Equals(Version, other.Version))
			{
				return false;
			}
			if (Metadata != other.Metadata)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Identifier.Length != 0)
			{
				num ^= Identifier.GetHashCode();
			}
			if (version_ != null)
			{
				num ^= Version.GetHashCode();
			}
			if (Metadata.Length != 0)
			{
				num ^= Metadata.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Identifier.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Identifier);
			}
			if (version_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Version);
			}
			if (Metadata.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(Metadata);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Identifier.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Identifier);
			}
			if (version_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Version);
			}
			if (Metadata.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Metadata);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedUserObject other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Identifier.Length != 0)
			{
				Identifier = other.Identifier;
			}
			if (other.version_ != null)
			{
				if (version_ == null)
				{
					Version = new VersionDef();
				}
				Version.MergeFrom(other.Version);
			}
			if (other.Metadata.Length != 0)
			{
				Metadata = other.Metadata;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Identifier = input.ReadString();
					break;
				case 18u:
					if (version_ == null)
					{
						Version = new VersionDef();
					}
					input.ReadMessage((IMessage)(object)Version);
					break;
				case 26u:
					Metadata = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class SavedAsset : IMessage<SavedAsset>, IMessage, IEquatable<SavedAsset>, IDeepCloneable<SavedAsset>
	{
		private static readonly MessageParser<SavedAsset> _parser = new MessageParser<SavedAsset>((Func<SavedAsset>)(() => new SavedAsset()));

		private UnknownFieldSet _unknownFields;

		public const int AssetFileDefIndexFieldNumber = 1;

		private int assetFileDefIndex_;

		[DebuggerNonUserCode]
		public static MessageParser<SavedAsset> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int AssetFileDefIndex
		{
			get
			{
				return assetFileDefIndex_;
			}
			set
			{
				assetFileDefIndex_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SavedAsset()
		{
		}

		[DebuggerNonUserCode]
		public SavedAsset(SavedAsset other)
			: this()
		{
			assetFileDefIndex_ = other.assetFileDefIndex_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedAsset Clone()
		{
			return new SavedAsset(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedAsset);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedAsset other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (AssetFileDefIndex != other.AssetFileDefIndex)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (AssetFileDefIndex != 0)
			{
				num ^= AssetFileDefIndex.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (AssetFileDefIndex != 0)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt32(AssetFileDefIndex);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (AssetFileDefIndex != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(AssetFileDefIndex);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedAsset other)
		{
			if (other != null)
			{
				if (other.AssetFileDefIndex != 0)
				{
					AssetFileDefIndex = other.AssetFileDefIndex;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					AssetFileDefIndex = input.ReadInt32();
				}
			}
		}
	}
	public sealed class SavedFunction : IMessage<SavedFunction>, IMessage, IEquatable<SavedFunction>, IDeepCloneable<SavedFunction>
	{
		private static readonly MessageParser<SavedFunction> _parser = new MessageParser<SavedFunction>((Func<SavedFunction>)(() => new SavedFunction()));

		private UnknownFieldSet _unknownFields;

		public const int ConcreteFunctionsFieldNumber = 1;

		private static readonly FieldCodec<string> _repeated_concreteFunctions_codec = FieldCodec.ForString(10u);

		private readonly RepeatedField<string> concreteFunctions_ = new RepeatedField<string>();

		public const int FunctionSpecFieldNumber = 2;

		private FunctionSpec functionSpec_;

		[DebuggerNonUserCode]
		public static MessageParser<SavedFunction> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<string> ConcreteFunctions => concreteFunctions_;

		[DebuggerNonUserCode]
		public FunctionSpec FunctionSpec
		{
			get
			{
				return functionSpec_;
			}
			set
			{
				functionSpec_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SavedFunction()
		{
		}

		[DebuggerNonUserCode]
		public SavedFunction(SavedFunction other)
			: this()
		{
			concreteFunctions_ = other.concreteFunctions_.Clone();
			functionSpec_ = ((other.functionSpec_ != null) ? other.functionSpec_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedFunction Clone()
		{
			return new SavedFunction(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedFunction);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedFunction other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!concreteFunctions_.Equals(other.concreteFunctions_))
			{
				return false;
			}
			if (!object.Equals(FunctionSpec, other.FunctionSpec))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)concreteFunctions_).GetHashCode();
			if (functionSpec_ != null)
			{
				num ^= FunctionSpec.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			concreteFunctions_.WriteTo(output, _repeated_concreteFunctions_codec);
			if (functionSpec_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)FunctionSpec);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += concreteFunctions_.CalculateSize(_repeated_concreteFunctions_codec);
			if (functionSpec_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)FunctionSpec);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedFunction other)
		{
			if (other == null)
			{
				return;
			}
			concreteFunctions_.Add((IEnumerable<string>)other.concreteFunctions_);
			if (other.functionSpec_ != null)
			{
				if (functionSpec_ == null)
				{
					FunctionSpec = new FunctionSpec();
				}
				FunctionSpec.MergeFrom(other.FunctionSpec);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					concreteFunctions_.AddEntriesFrom(input, _repeated_concreteFunctions_codec);
					break;
				case 18u:
					if (functionSpec_ == null)
					{
						FunctionSpec = new FunctionSpec();
					}
					input.ReadMessage((IMessage)(object)FunctionSpec);
					break;
				}
			}
		}
	}
	public sealed class CapturedTensor : IMessage<CapturedTensor>, IMessage, IEquatable<CapturedTensor>, IDeepCloneable<CapturedTensor>
	{
		private static readonly MessageParser<CapturedTensor> _parser = new MessageParser<CapturedTensor>((Func<CapturedTensor>)(() => new CapturedTensor()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int ConcreteFunctionFieldNumber = 2;

		private string concreteFunction_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<CapturedTensor> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string ConcreteFunction
		{
			get
			{
				return concreteFunction_;
			}
			set
			{
				concreteFunction_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public CapturedTensor()
		{
		}

		[DebuggerNonUserCode]
		public CapturedTensor(CapturedTensor other)
			: this()
		{
			name_ = other.name_;
			concreteFunction_ = other.concreteFunction_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CapturedTensor Clone()
		{
			return new CapturedTensor(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CapturedTensor);
		}

		[DebuggerNonUserCode]
		public bool Equals(CapturedTensor other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (ConcreteFunction != other.ConcreteFunction)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (ConcreteFunction.Length != 0)
			{
				num ^= ConcreteFunction.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (ConcreteFunction.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(ConcreteFunction);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (ConcreteFunction.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ConcreteFunction);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CapturedTensor other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.ConcreteFunction.Length != 0)
				{
					ConcreteFunction = other.ConcreteFunction;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					ConcreteFunction = input.ReadString();
					break;
				}
			}
		}
	}
	public sealed class SavedConcreteFunction : IMessage<SavedConcreteFunction>, IMessage, IEquatable<SavedConcreteFunction>, IDeepCloneable<SavedConcreteFunction>
	{
		private static readonly MessageParser<SavedConcreteFunction> _parser = new MessageParser<SavedConcreteFunction>((Func<SavedConcreteFunction>)(() => new SavedConcreteFunction()));

		private UnknownFieldSet _unknownFields;

		public const int BoundInputsFieldNumber = 2;

		private static readonly FieldCodec<int> _repeated_boundInputs_codec = FieldCodec.ForInt32(18u);

		private readonly RepeatedField<int> boundInputs_ = new RepeatedField<int>();

		public const int CanonicalizedInputSignatureFieldNumber = 3;

		private StructuredValue canonicalizedInputSignature_;

		public const int OutputSignatureFieldNumber = 4;

		private StructuredValue outputSignature_;

		[DebuggerNonUserCode]
		public static MessageParser<SavedConcreteFunction> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<int> BoundInputs => boundInputs_;

		[DebuggerNonUserCode]
		public StructuredValue CanonicalizedInputSignature
		{
			get
			{
				return canonicalizedInputSignature_;
			}
			set
			{
				canonicalizedInputSignature_ = value;
			}
		}

		[DebuggerNonUserCode]
		public StructuredValue OutputSignature
		{
			get
			{
				return outputSignature_;
			}
			set
			{
				outputSignature_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SavedConcreteFunction()
		{
		}

		[DebuggerNonUserCode]
		public SavedConcreteFunction(SavedConcreteFunction other)
			: this()
		{
			boundInputs_ = other.boundInputs_.Clone();
			canonicalizedInputSignature_ = ((other.canonicalizedInputSignature_ != null) ? other.canonicalizedInputSignature_.Clone() : null);
			outputSignature_ = ((other.outputSignature_ != null) ? other.outputSignature_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedConcreteFunction Clone()
		{
			return new SavedConcreteFunction(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedConcreteFunction);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedConcreteFunction other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!boundInputs_.Equals(other.boundInputs_))
			{
				return false;
			}
			if (!object.Equals(CanonicalizedInputSignature, other.CanonicalizedInputSignature))
			{
				return false;
			}
			if (!object.Equals(OutputSignature, other.OutputSignature))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)boundInputs_).GetHashCode();
			if (canonicalizedInputSignature_ != null)
			{
				num ^= CanonicalizedInputSignature.GetHashCode();
			}
			if (outputSignature_ != null)
			{
				num ^= OutputSignature.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			boundInputs_.WriteTo(output, _repeated_boundInputs_codec);
			if (canonicalizedInputSignature_ != null)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)CanonicalizedInputSignature);
			}
			if (outputSignature_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)OutputSignature);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += boundInputs_.CalculateSize(_repeated_boundInputs_codec);
			if (canonicalizedInputSignature_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CanonicalizedInputSignature);
			}
			if (outputSignature_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)OutputSignature);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedConcreteFunction other)
		{
			if (other == null)
			{
				return;
			}
			boundInputs_.Add((IEnumerable<int>)other.boundInputs_);
			if (other.canonicalizedInputSignature_ != null)
			{
				if (canonicalizedInputSignature_ == null)
				{
					CanonicalizedInputSignature = new StructuredValue();
				}
				CanonicalizedInputSignature.MergeFrom(other.CanonicalizedInputSignature);
			}
			if (other.outputSignature_ != null)
			{
				if (outputSignature_ == null)
				{
					OutputSignature = new StructuredValue();
				}
				OutputSignature.MergeFrom(other.OutputSignature);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 16u:
				case 18u:
					boundInputs_.AddEntriesFrom(input, _repeated_boundInputs_codec);
					break;
				case 26u:
					if (canonicalizedInputSignature_ == null)
					{
						CanonicalizedInputSignature = new StructuredValue();
					}
					input.ReadMessage((IMessage)(object)CanonicalizedInputSignature);
					break;
				case 34u:
					if (outputSignature_ == null)
					{
						OutputSignature = new StructuredValue();
					}
					input.ReadMessage((IMessage)(object)OutputSignature);
					break;
				}
			}
		}
	}
	public sealed class SavedBareConcreteFunction : IMessage<SavedBareConcreteFunction>, IMessage, IEquatable<SavedBareConcreteFunction>, IDeepCloneable<SavedBareConcreteFunction>
	{
		private static readonly MessageParser<SavedBareConcreteFunction> _parser = new MessageParser<SavedBareConcreteFunction>((Func<SavedBareConcreteFunction>)(() => new SavedBareConcreteFunction()));

		private UnknownFieldSet _unknownFields;

		public const int ConcreteFunctionNameFieldNumber = 1;

		private string concreteFunctionName_ = "";

		public const int ArgumentKeywordsFieldNumber = 2;

		private static readonly FieldCodec<string> _repeated_argumentKeywords_codec = FieldCodec.ForString(18u);

		private readonly RepeatedField<string> argumentKeywords_ = new RepeatedField<string>();

		public const int AllowedPositionalArgumentsFieldNumber = 3;

		private long allowedPositionalArguments_;

		public const int FunctionSpecFieldNumber = 4;

		private FunctionSpec functionSpec_;

		[DebuggerNonUserCode]
		public static MessageParser<SavedBareConcreteFunction> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string ConcreteFunctionName
		{
			get
			{
				return concreteFunctionName_;
			}
			set
			{
				concreteFunctionName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> ArgumentKeywords => argumentKeywords_;

		[DebuggerNonUserCode]
		public long AllowedPositionalArguments
		{
			get
			{
				return allowedPositionalArguments_;
			}
			set
			{
				allowedPositionalArguments_ = value;
			}
		}

		[DebuggerNonUserCode]
		public FunctionSpec FunctionSpec
		{
			get
			{
				return functionSpec_;
			}
			set
			{
				functionSpec_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SavedBareConcreteFunction()
		{
		}

		[DebuggerNonUserCode]
		public SavedBareConcreteFunction(SavedBareConcreteFunction other)
			: this()
		{
			concreteFunctionName_ = other.concreteFunctionName_;
			argumentKeywords_ = other.argumentKeywords_.Clone();
			allowedPositionalArguments_ = other.allowedPositionalArguments_;
			functionSpec_ = ((other.functionSpec_ != null) ? other.functionSpec_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedBareConcreteFunction Clone()
		{
			return new SavedBareConcreteFunction(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedBareConcreteFunction);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedBareConcreteFunction other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (ConcreteFunctionName != other.ConcreteFunctionName)
			{
				return false;
			}
			if (!argumentKeywords_.Equals(other.argumentKeywords_))
			{
				return false;
			}
			if (AllowedPositionalArguments != other.AllowedPositionalArguments)
			{
				return false;
			}
			if (!object.Equals(FunctionSpec, other.FunctionSpec))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (ConcreteFunctionName.Length != 0)
			{
				num ^= ConcreteFunctionName.GetHashCode();
			}
			num ^= ((object)argumentKeywords_).GetHashCode();
			if (AllowedPositionalArguments != 0L)
			{
				num ^= AllowedPositionalArguments.GetHashCode();
			}
			if (functionSpec_ != null)
			{
				num ^= FunctionSpec.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (ConcreteFunctionName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(ConcreteFunctionName);
			}
			argumentKeywords_.WriteTo(output, _repeated_argumentKeywords_codec);
			if (AllowedPositionalArguments != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(AllowedPositionalArguments);
			}
			if (functionSpec_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)FunctionSpec);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (ConcreteFunctionName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ConcreteFunctionName);
			}
			num += argumentKeywords_.CalculateSize(_repeated_argumentKeywords_codec);
			if (AllowedPositionalArguments != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllowedPositionalArguments);
			}
			if (functionSpec_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)FunctionSpec);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedBareConcreteFunction other)
		{
			if (other == null)
			{
				return;
			}
			if (other.ConcreteFunctionName.Length != 0)
			{
				ConcreteFunctionName = other.ConcreteFunctionName;
			}
			argumentKeywords_.Add((IEnumerable<string>)other.argumentKeywords_);
			if (other.AllowedPositionalArguments != 0L)
			{
				AllowedPositionalArguments = other.AllowedPositionalArguments;
			}
			if (other.functionSpec_ != null)
			{
				if (functionSpec_ == null)
				{
					FunctionSpec = new FunctionSpec();
				}
				FunctionSpec.MergeFrom(other.FunctionSpec);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					ConcreteFunctionName = input.ReadString();
					break;
				case 18u:
					argumentKeywords_.AddEntriesFrom(input, _repeated_argumentKeywords_codec);
					break;
				case 24u:
					AllowedPositionalArguments = input.ReadInt64();
					break;
				case 34u:
					if (functionSpec_ == null)
					{
						FunctionSpec = new FunctionSpec();
					}
					input.ReadMessage((IMessage)(object)FunctionSpec);
					break;
				}
			}
		}
	}
	public sealed class SavedConstant : IMessage<SavedConstant>, IMessage, IEquatable<SavedConstant>, IDeepCloneable<SavedConstant>
	{
		private static readonly MessageParser<SavedConstant> _parser = new MessageParser<SavedConstant>((Func<SavedConstant>)(() => new SavedConstant()));

		private UnknownFieldSet _unknownFields;

		public const int OperationFieldNumber = 1;

		private string operation_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<SavedConstant> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Operation
		{
			get
			{
				return operation_;
			}
			set
			{
				operation_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SavedConstant()
		{
		}

		[DebuggerNonUserCode]
		public SavedConstant(SavedConstant other)
			: this()
		{
			operation_ = other.operation_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedConstant Clone()
		{
			return new SavedConstant(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedConstant);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedConstant other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Operation != other.Operation)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Operation.Length != 0)
			{
				num ^= Operation.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Operation.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Operation);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Operation.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Operation);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedConstant other)
		{
			if (other != null)
			{
				if (other.Operation.Length != 0)
				{
					Operation = other.Operation;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					Operation = input.ReadString();
				}
			}
		}
	}
	public sealed class SavedVariable : IMessage<SavedVariable>, IMessage, IEquatable<SavedVariable>, IDeepCloneable<SavedVariable>
	{
		private static readonly MessageParser<SavedVariable> _parser = new MessageParser<SavedVariable>((Func<SavedVariable>)(() => new SavedVariable()));

		private UnknownFieldSet _unknownFields;

		public const int DtypeFieldNumber = 1;

		private DataType dtype_;

		public const int ShapeFieldNumber = 2;

		private TensorShapeProto shape_;

		public const int TrainableFieldNumber = 3;

		private bool trainable_;

		public const int SynchronizationFieldNumber = 4;

		private VariableSynchronization synchronization_;

		public const int AggregationFieldNumber = 5;

		private VariableAggregation aggregation_;

		public const int NameFieldNumber = 6;

		private string name_ = "";

		public const int DeviceFieldNumber = 7;

		private string device_ = "";

		public const int ExperimentalDistributedVariableComponentsFieldNumber = 8;

		private static readonly FieldCodec<SavedVariable> _repeated_experimentalDistributedVariableComponents_codec = FieldCodec.ForMessage<SavedVariable>(66u, Parser);

		private readonly RepeatedField<SavedVariable> experimentalDistributedVariableComponents_ = new RepeatedField<SavedVariable>();

		[DebuggerNonUserCode]
		public static MessageParser<SavedVariable> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[9];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public DataType Dtype
		{
			get
			{
				return dtype_;
			}
			set
			{
				dtype_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto Shape
		{
			get
			{
				return shape_;
			}
			set
			{
				shape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool Trainable
		{
			get
			{
				return trainable_;
			}
			set
			{
				trainable_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VariableSynchronization Synchronization
		{
			get
			{
				return synchronization_;
			}
			set
			{
				synchronization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VariableAggregation Aggregation
		{
			get
			{
				return aggregation_;
			}
			set
			{
				aggregation_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Device
		{
			get
			{
				return device_;
			}
			set
			{
				device_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<SavedVariable> ExperimentalDistributedVariableComponents => experimentalDistributedVariableComponents_;

		[DebuggerNonUserCode]
		public SavedVariable()
		{
		}

		[DebuggerNonUserCode]
		public SavedVariable(SavedVariable other)
			: this()
		{
			dtype_ = other.dtype_;
			shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
			trainable_ = other.trainable_;
			synchronization_ = other.synchronization_;
			aggregation_ = other.aggregation_;
			name_ = other.name_;
			device_ = other.device_;
			experimentalDistributedVariableComponents_ = other.experimentalDistributedVariableComponents_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedVariable Clone()
		{
			return new SavedVariable(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedVariable);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedVariable other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Dtype != other.Dtype)
			{
				return false;
			}
			if (!object.Equals(Shape, other.Shape))
			{
				return false;
			}
			if (Trainable != other.Trainable)
			{
				return false;
			}
			if (Synchronization != other.Synchronization)
			{
				return false;
			}
			if (Aggregation != other.Aggregation)
			{
				return false;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Device != other.Device)
			{
				return false;
			}
			if (!experimentalDistributedVariableComponents_.Equals(other.experimentalDistributedVariableComponents_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Dtype != DataType.DtInvalid)
			{
				num ^= Dtype.GetHashCode();
			}
			if (shape_ != null)
			{
				num ^= Shape.GetHashCode();
			}
			if (Trainable)
			{
				num ^= Trainable.GetHashCode();
			}
			if (Synchronization != VariableSynchronization.Auto)
			{
				num ^= Synchronization.GetHashCode();
			}
			if (Aggregation != VariableAggregation.None)
			{
				num ^= Aggregation.GetHashCode();
			}
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (Device.Length != 0)
			{
				num ^= Device.GetHashCode();
			}
			num ^= ((object)experimentalDistributedVariableComponents_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Dtype != DataType.DtInvalid)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)Dtype);
			}
			if (shape_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Shape);
			}
			if (Trainable)
			{
				output.WriteRawTag((byte)24);
				output.WriteBool(Trainable);
			}
			if (Synchronization != VariableSynchronization.Auto)
			{
				output.WriteRawTag((byte)32);
				output.WriteEnum((int)Synchronization);
			}
			if (Aggregation != VariableAggregation.None)
			{
				output.WriteRawTag((byte)40);
				output.WriteEnum((int)Aggregation);
			}
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)50);
				output.WriteString(Name);
			}
			if (Device.Length != 0)
			{
				output.WriteRawTag((byte)58);
				output.WriteString(Device);
			}
			experimentalDistributedVariableComponents_.WriteTo(output, _repeated_experimentalDistributedVariableComponents_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Dtype != DataType.DtInvalid)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
			}
			if (shape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
			}
			if (Trainable)
			{
				num += 2;
			}
			if (Synchronization != VariableSynchronization.Auto)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Synchronization);
			}
			if (Aggregation != VariableAggregation.None)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Aggregation);
			}
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (Device.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Device);
			}
			num += experimentalDistributedVariableComponents_.CalculateSize(_repeated_experimentalDistributedVariableComponents_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedVariable other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Dtype != DataType.DtInvalid)
			{
				Dtype = other.Dtype;
			}
			if (other.shape_ != null)
			{
				if (shape_ == null)
				{
					Shape = new TensorShapeProto();
				}
				Shape.MergeFrom(other.Shape);
			}
			if (other.Trainable)
			{
				Trainable = other.Trainable;
			}
			if (other.Synchronization != VariableSynchronization.Auto)
			{
				Synchronization = other.Synchronization;
			}
			if (other.Aggregation != VariableAggregation.None)
			{
				Aggregation = other.Aggregation;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.Device.Length != 0)
			{
				Device = other.Device;
			}
			experimentalDistributedVariableComponents_.Add((IEnumerable<SavedVariable>)other.experimentalDistributedVariableComponents_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Dtype = (DataType)input.ReadEnum();
					break;
				case 18u:
					if (shape_ == null)
					{
						Shape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)Shape);
					break;
				case 24u:
					Trainable = input.ReadBool();
					break;
				case 32u:
					Synchronization = (VariableSynchronization)input.ReadEnum();
					break;
				case 40u:
					Aggregation = (VariableAggregation)input.ReadEnum();
					break;
				case 50u:
					Name = input.ReadString();
					break;
				case 58u:
					Device = input.ReadString();
					break;
				case 66u:
					experimentalDistributedVariableComponents_.AddEntriesFrom(input, _repeated_experimentalDistributedVariableComponents_codec);
					break;
				}
			}
		}
	}
	public sealed class FunctionSpec : IMessage<FunctionSpec>, IMessage, IEquatable<FunctionSpec>, IDeepCloneable<FunctionSpec>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum JitCompile
			{
				[OriginalName("DEFAULT")]
				Default,
				[OriginalName("ON")]
				On,
				[OriginalName("OFF")]
				Off
			}
		}

		private static readonly MessageParser<FunctionSpec> _parser = new MessageParser<FunctionSpec>((Func<FunctionSpec>)(() => new FunctionSpec()));

		private UnknownFieldSet _unknownFields;

		public const int FullargspecFieldNumber = 1;

		private StructuredValue fullargspec_;

		public const int IsMethodFieldNumber = 2;

		private bool isMethod_;

		public const int InputSignatureFieldNumber = 5;

		private StructuredValue inputSignature_;

		public const int JitCompileFieldNumber = 6;

		private Types.JitCompile jitCompile_;

		[DebuggerNonUserCode]
		public static MessageParser<FunctionSpec> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[10];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public StructuredValue Fullargspec
		{
			get
			{
				return fullargspec_;
			}
			set
			{
				fullargspec_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool IsMethod
		{
			get
			{
				return isMethod_;
			}
			set
			{
				isMethod_ = value;
			}
		}

		[DebuggerNonUserCode]
		public StructuredValue InputSignature
		{
			get
			{
				return inputSignature_;
			}
			set
			{
				inputSignature_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.JitCompile JitCompile
		{
			get
			{
				return jitCompile_;
			}
			set
			{
				jitCompile_ = value;
			}
		}

		[DebuggerNonUserCode]
		public FunctionSpec()
		{
		}

		[DebuggerNonUserCode]
		public FunctionSpec(FunctionSpec other)
			: this()
		{
			fullargspec_ = ((other.fullargspec_ != null) ? other.fullargspec_.Clone() : null);
			isMethod_ = other.isMethod_;
			inputSignature_ = ((other.inputSignature_ != null) ? other.inputSignature_.Clone() : null);
			jitCompile_ = other.jitCompile_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public FunctionSpec Clone()
		{
			return new FunctionSpec(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as FunctionSpec);
		}

		[DebuggerNonUserCode]
		public bool Equals(FunctionSpec other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(Fullargspec, other.Fullargspec))
			{
				return false;
			}
			if (IsMethod != other.IsMethod)
			{
				return false;
			}
			if (!object.Equals(InputSignature, other.InputSignature))
			{
				return false;
			}
			if (JitCompile != other.JitCompile)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (fullargspec_ != null)
			{
				num ^= Fullargspec.GetHashCode();
			}
			if (IsMethod)
			{
				num ^= IsMethod.GetHashCode();
			}
			if (inputSignature_ != null)
			{
				num ^= InputSignature.GetHashCode();
			}
			if (JitCompile != Types.JitCompile.Default)
			{
				num ^= JitCompile.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (fullargspec_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)Fullargspec);
			}
			if (IsMethod)
			{
				output.WriteRawTag((byte)16);
				output.WriteBool(IsMethod);
			}
			if (inputSignature_ != null)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)InputSignature);
			}
			if (JitCompile != Types.JitCompile.Default)
			{
				output.WriteRawTag((byte)48);
				output.WriteEnum((int)JitCompile);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (fullargspec_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Fullargspec);
			}
			if (IsMethod)
			{
				num += 2;
			}
			if (inputSignature_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)InputSignature);
			}
			if (JitCompile != Types.JitCompile.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)JitCompile);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(FunctionSpec other)
		{
			if (other == null)
			{
				return;
			}
			if (other.fullargspec_ != null)
			{
				if (fullargspec_ == null)
				{
					Fullargspec = new StructuredValue();
				}
				Fullargspec.MergeFrom(other.Fullargspec);
			}
			if (other.IsMethod)
			{
				IsMethod = other.IsMethod;
			}
			if (other.inputSignature_ != null)
			{
				if (inputSignature_ == null)
				{
					InputSignature = new StructuredValue();
				}
				InputSignature.MergeFrom(other.InputSignature);
			}
			if (other.JitCompile != Types.JitCompile.Default)
			{
				JitCompile = other.JitCompile;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (fullargspec_ == null)
					{
						Fullargspec = new StructuredValue();
					}
					input.ReadMessage((IMessage)(object)Fullargspec);
					break;
				case 16u:
					IsMethod = input.ReadBool();
					break;
				case 42u:
					if (inputSignature_ == null)
					{
						InputSignature = new StructuredValue();
					}
					input.ReadMessage((IMessage)(object)InputSignature);
					break;
				case 48u:
					JitCompile = (Types.JitCompile)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class SavedResource : IMessage<SavedResource>, IMessage, IEquatable<SavedResource>, IDeepCloneable<SavedResource>
	{
		private static readonly MessageParser<SavedResource> _parser = new MessageParser<SavedResource>((Func<SavedResource>)(() => new SavedResource()));

		private UnknownFieldSet _unknownFields;

		public const int DeviceFieldNumber = 1;

		private string device_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<SavedResource> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[11];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Device
		{
			get
			{
				return device_;
			}
			set
			{
				device_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SavedResource()
		{
		}

		[DebuggerNonUserCode]
		public SavedResource(SavedResource other)
			: this()
		{
			device_ = other.device_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SavedResource Clone()
		{
			return new SavedResource(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SavedResource);
		}

		[DebuggerNonUserCode]
		public bool Equals(SavedResource other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Device != other.Device)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Device.Length != 0)
			{
				num ^= Device.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Device.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Device);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Device.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Device);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SavedResource other)
		{
			if (other != null)
			{
				if (other.Device.Length != 0)
				{
					Device = other.Device;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					Device = input.ReadString();
				}
			}
		}
	}
	public sealed class SaveableObject : IMessage<SaveableObject>, IMessage, IEquatable<SaveableObject>, IDeepCloneable<SaveableObject>
	{
		private static readonly MessageParser<SaveableObject> _parser = new MessageParser<SaveableObject>((Func<SaveableObject>)(() => new SaveableObject()));

		private UnknownFieldSet _unknownFields;

		public const int SaveFunctionFieldNumber = 2;

		private int saveFunction_;

		public const int RestoreFunctionFieldNumber = 3;

		private int restoreFunction_;

		[DebuggerNonUserCode]
		public static MessageParser<SaveableObject> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SavedObjectGraphReflection.Descriptor.MessageTypes[12];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int SaveFunction
		{
			get
			{
				return saveFunction_;
			}
			set
			{
				saveFunction_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int RestoreFunction
		{
			get
			{
				return restoreFunction_;
			}
			set
			{
				restoreFunction_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SaveableObject()
		{
		}

		[DebuggerNonUserCode]
		public SaveableObject(SaveableObject other)
			: this()
		{
			saveFunction_ = other.saveFunction_;
			restoreFunction_ = other.restoreFunction_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SaveableObject Clone()
		{
			return new SaveableObject(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SaveableObject);
		}

		[DebuggerNonUserCode]
		public bool Equals(SaveableObject other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (SaveFunction != other.SaveFunction)
			{
				return false;
			}
			if (RestoreFunction != other.RestoreFunction)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (SaveFunction != 0)
			{
				num ^= SaveFunction.GetHashCode();
			}
			if (RestoreFunction != 0)
			{
				num ^= RestoreFunction.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (SaveFunction != 0)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt32(SaveFunction);
			}
			if (RestoreFunction != 0)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt32(RestoreFunction);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (SaveFunction != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(SaveFunction);
			}
			if (RestoreFunction != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(RestoreFunction);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SaveableObject other)
		{
			if (other != null)
			{
				if (other.SaveFunction != 0)
				{
					SaveFunction = other.SaveFunction;
				}
				if (other.RestoreFunction != 0)
				{
					RestoreFunction = other.RestoreFunction;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 16u:
					SaveFunction = input.ReadInt32();
					break;
				case 24u:
					RestoreFunction = input.ReadInt32();
					break;
				}
			}
		}
	}
	public static class SaverReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static SaverReflection()
		{
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiR0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc2F2ZXIucHJvdG8SC3RlbnNv" + "cmJvYXJkIp8CCghTYXZlckRlZhIcChRmaWxlbmFtZV90ZW5zb3JfbmFtZRgB" + "IAEoCRIYChBzYXZlX3RlbnNvcl9uYW1lGAIgASgJEhcKD3Jlc3RvcmVfb3Bf" + "bmFtZRgDIAEoCRITCgttYXhfdG9fa2VlcBgEIAEoBRIPCgdzaGFyZGVkGAUg" + "ASgIEiUKHWtlZXBfY2hlY2twb2ludF9ldmVyeV9uX2hvdXJzGAYgASgCEj4K" + "B3ZlcnNpb24YByABKA4yLS50ZW5zb3Jib2FyZC5TYXZlckRlZi5DaGVja3Bv" + "aW50Rm9ybWF0VmVyc2lvbiI1ChdDaGVja3BvaW50Rm9ybWF0VmVyc2lvbhIK" + "CgZMRUdBQ1kQABIGCgJWMRABEgYKAlYyEAJCfgoTb3JnLnRlbnNvcmZsb3cu" + "dXRpbEILU2F2ZXJQcm90b3NQAVpVZ2l0aHViLmNvbS90ZW5zb3JmbG93L3Rl" + "bnNvcmZsb3cvdGVuc29yZmxvdy9nby9jb3JlL3Byb3RvYnVmL2Zvcl9jb3Jl" + "X3Byb3Rvc19nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(SaverDef), (MessageParser)(object)SaverDef.Parser, new string[7] { "FilenameTensorName", "SaveTensorName", "RestoreOpName", "MaxToKeep", "Sharded", "KeepCheckpointEveryNHours", "Version" }, (string[])null, new Type[1] { typeof(SaverDef.Types.CheckpointFormatVersion) }, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class SaverDef : IMessage<SaverDef>, IMessage, IEquatable<SaverDef>, IDeepCloneable<SaverDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum CheckpointFormatVersion
			{
				[OriginalName("LEGACY")]
				Legacy,
				[OriginalName("V1")]
				V1,
				[OriginalName("V2")]
				V2
			}
		}

		private static readonly MessageParser<SaverDef> _parser = new MessageParser<SaverDef>((Func<SaverDef>)(() => new SaverDef()));

		private UnknownFieldSet _unknownFields;

		public const int FilenameTensorNameFieldNumber = 1;

		private string filenameTensorName_ = "";

		public const int SaveTensorNameFieldNumber = 2;

		private string saveTensorName_ = "";

		public const int RestoreOpNameFieldNumber = 3;

		private string restoreOpName_ = "";

		public const int MaxToKeepFieldNumber = 4;

		private int maxToKeep_;

		public const int ShardedFieldNumber = 5;

		private bool sharded_;

		public const int KeepCheckpointEveryNHoursFieldNumber = 6;

		private float keepCheckpointEveryNHours_;

		public const int VersionFieldNumber = 7;

		private Types.CheckpointFormatVersion version_;

		[DebuggerNonUserCode]
		public static MessageParser<SaverDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SaverReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string FilenameTensorName
		{
			get
			{
				return filenameTensorName_;
			}
			set
			{
				filenameTensorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string SaveTensorName
		{
			get
			{
				return saveTensorName_;
			}
			set
			{
				saveTensorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string RestoreOpName
		{
			get
			{
				return restoreOpName_;
			}
			set
			{
				restoreOpName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public int MaxToKeep
		{
			get
			{
				return maxToKeep_;
			}
			set
			{
				maxToKeep_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool Sharded
		{
			get
			{
				return sharded_;
			}
			set
			{
				sharded_ = value;
			}
		}

		[DebuggerNonUserCode]
		public float KeepCheckpointEveryNHours
		{
			get
			{
				return keepCheckpointEveryNHours_;
			}
			set
			{
				keepCheckpointEveryNHours_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.CheckpointFormatVersion Version
		{
			get
			{
				return version_;
			}
			set
			{
				version_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SaverDef()
		{
		}

		[DebuggerNonUserCode]
		public SaverDef(SaverDef other)
			: this()
		{
			filenameTensorName_ = other.filenameTensorName_;
			saveTensorName_ = other.saveTensorName_;
			restoreOpName_ = other.restoreOpName_;
			maxToKeep_ = other.maxToKeep_;
			sharded_ = other.sharded_;
			keepCheckpointEveryNHours_ = other.keepCheckpointEveryNHours_;
			version_ = other.version_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SaverDef Clone()
		{
			return new SaverDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SaverDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(SaverDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (FilenameTensorName != other.FilenameTensorName)
			{
				return false;
			}
			if (SaveTensorName != other.SaveTensorName)
			{
				return false;
			}
			if (RestoreOpName != other.RestoreOpName)
			{
				return false;
			}
			if (MaxToKeep != other.MaxToKeep)
			{
				return false;
			}
			if (Sharded != other.Sharded)
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(KeepCheckpointEveryNHours, other.KeepCheckpointEveryNHours))
			{
				return false;
			}
			if (Version != other.Version)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (FilenameTensorName.Length != 0)
			{
				num ^= FilenameTensorName.GetHashCode();
			}
			if (SaveTensorName.Length != 0)
			{
				num ^= SaveTensorName.GetHashCode();
			}
			if (RestoreOpName.Length != 0)
			{
				num ^= RestoreOpName.GetHashCode();
			}
			if (MaxToKeep != 0)
			{
				num ^= MaxToKeep.GetHashCode();
			}
			if (Sharded)
			{
				num ^= Sharded.GetHashCode();
			}
			if (KeepCheckpointEveryNHours != 0f)
			{
				num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(KeepCheckpointEveryNHours);
			}
			if (Version != Types.CheckpointFormatVersion.Legacy)
			{
				num ^= Version.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (FilenameTensorName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(FilenameTensorName);
			}
			if (SaveTensorName.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(SaveTensorName);
			}
			if (RestoreOpName.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(RestoreOpName);
			}
			if (MaxToKeep != 0)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt32(MaxToKeep);
			}
			if (Sharded)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(Sharded);
			}
			if (KeepCheckpointEveryNHours != 0f)
			{
				output.WriteRawTag((byte)53);
				output.WriteFloat(KeepCheckpointEveryNHours);
			}
			if (Version != Types.CheckpointFormatVersion.Legacy)
			{
				output.WriteRawTag((byte)56);
				output.WriteEnum((int)Version);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (FilenameTensorName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FilenameTensorName);
			}
			if (SaveTensorName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(SaveTensorName);
			}
			if (RestoreOpName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(RestoreOpName);
			}
			if (MaxToKeep != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(MaxToKeep);
			}
			if (Sharded)
			{
				num += 2;
			}
			if (KeepCheckpointEveryNHours != 0f)
			{
				num += 5;
			}
			if (Version != Types.CheckpointFormatVersion.Legacy)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Version);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SaverDef other)
		{
			if (other != null)
			{
				if (other.FilenameTensorName.Length != 0)
				{
					FilenameTensorName = other.FilenameTensorName;
				}
				if (other.SaveTensorName.Length != 0)
				{
					SaveTensorName = other.SaveTensorName;
				}
				if (other.RestoreOpName.Length != 0)
				{
					RestoreOpName = other.RestoreOpName;
				}
				if (other.MaxToKeep != 0)
				{
					MaxToKeep = other.MaxToKeep;
				}
				if (other.Sharded)
				{
					Sharded = other.Sharded;
				}
				if (other.KeepCheckpointEveryNHours != 0f)
				{
					KeepCheckpointEveryNHours = other.KeepCheckpointEveryNHours;
				}
				if (other.Version != Types.CheckpointFormatVersion.Legacy)
				{
					Version = other.Version;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					FilenameTensorName = input.ReadString();
					break;
				case 18u:
					SaveTensorName = input.ReadString();
					break;
				case 26u:
					RestoreOpName = input.ReadString();
					break;
				case 32u:
					MaxToKeep = input.ReadInt32();
					break;
				case 40u:
					Sharded = input.ReadBool();
					break;
				case 53u:
					KeepCheckpointEveryNHours = input.ReadFloat();
					break;
				case 56u:
					Version = (Types.CheckpointFormatVersion)input.ReadEnum();
					break;
				}
			}
		}
	}
	public static class StepStatsReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static StepStatsReflection()
		{
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: Expected O, but got Unknown
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0370: Expected O, but got Unknown
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Expected O, but got Unknown
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc3RlcF9zdGF0cy5wcm90bxIL" + "dGVuc29yYm9hcmQaNXRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9hbGxvY2F0" + "aW9uX2Rlc2NyaXB0aW9uLnByb3RvGjF0ZW5zb3Jib2FyZC9jb21wYXQvcHJv" + "dG8vdGVuc29yX2Rlc2NyaXB0aW9uLnByb3RvIj0KEEFsbG9jYXRpb25SZWNv" + "cmQSFAoMYWxsb2NfbWljcm9zGAEgASgDEhMKC2FsbG9jX2J5dGVzGAIgASgD" + "IsUBChNBbGxvY2F0b3JNZW1vcnlVc2VkEhYKDmFsbG9jYXRvcl9uYW1lGAEg" + "ASgJEhMKC3RvdGFsX2J5dGVzGAIgASgDEhIKCnBlYWtfYnl0ZXMYAyABKAMS" + "EgoKbGl2ZV9ieXRlcxgEIAEoAxI5ChJhbGxvY2F0aW9uX3JlY29yZHMYBiAD" + "KAsyHS50ZW5zb3Jib2FyZC5BbGxvY2F0aW9uUmVjb3JkEh4KFmFsbG9jYXRv" + "cl9ieXRlc19pbl91c2UYBSABKAMiVgoKTm9kZU91dHB1dBIMCgRzbG90GAEg" + "ASgFEjoKEnRlbnNvcl9kZXNjcmlwdGlvbhgDIAEoCzIeLnRlbnNvcmJvYXJk" + "LlRlbnNvckRlc2NyaXB0aW9uIuwBCgtNZW1vcnlTdGF0cxIYChB0ZW1wX21l" + "bW9yeV9zaXplGAEgASgDEh4KFnBlcnNpc3RlbnRfbWVtb3J5X3NpemUYAyAB" + "KAMSIwobcGVyc2lzdGVudF90ZW5zb3JfYWxsb2NfaWRzGAUgAygDEiMKF2Rl" + "dmljZV90ZW1wX21lbW9yeV9zaXplGAIgASgDQgIYARIpCh1kZXZpY2VfcGVy" + "c2lzdGVudF9tZW1vcnlfc2l6ZRgEIAEoA0ICGAESLgoiZGV2aWNlX3BlcnNp" + "c3RlbnRfdGVuc29yX2FsbG9jX2lkcxgGIAMoA0ICGAEiogQKDU5vZGVFeGVj" + "U3RhdHMSEQoJbm9kZV9uYW1lGAEgASgJEhgKEGFsbF9zdGFydF9taWNyb3MY" + "AiABKAMSGwoTb3Bfc3RhcnRfcmVsX21pY3JvcxgDIAEoAxIZChFvcF9lbmRf" + "cmVsX21pY3JvcxgEIAEoAxIaChJhbGxfZW5kX3JlbF9taWNyb3MYBSABKAMS" + "MAoGbWVtb3J5GAYgAygLMiAudGVuc29yYm9hcmQuQWxsb2NhdG9yTWVtb3J5" + "VXNlZBInCgZvdXRwdXQYByADKAsyFy50ZW5zb3Jib2FyZC5Ob2RlT3V0cHV0" + "EhYKDnRpbWVsaW5lX2xhYmVsGAggASgJEhgKEHNjaGVkdWxlZF9taWNyb3MY" + "CSABKAMSEQoJdGhyZWFkX2lkGAogASgNEj0KEXJlZmVyZW5jZWRfdGVuc29y" + "GAsgAygLMiIudGVuc29yYm9hcmQuQWxsb2NhdGlvbkRlc2NyaXB0aW9uEi4K" + "DG1lbW9yeV9zdGF0cxgMIAEoCzIYLnRlbnNvcmJvYXJkLk1lbW9yeVN0YXRz" + "EhcKD2FsbF9zdGFydF9uYW5vcxgNIAEoAxIaChJvcF9zdGFydF9yZWxfbmFu" + "b3MYDiABKAMSGAoQb3BfZW5kX3JlbF9uYW5vcxgPIAEoAxIZChFhbGxfZW5k" + "X3JlbF9uYW5vcxgQIAEoAxIXCg9zY2hlZHVsZWRfbmFub3MYESABKAMiygEK" + "D0RldmljZVN0ZXBTdGF0cxIOCgZkZXZpY2UYASABKAkSLgoKbm9kZV9zdGF0" + "cxgCIAMoCzIaLnRlbnNvcmJvYXJkLk5vZGVFeGVjU3RhdHMSQwoMdGhyZWFk" + "X25hbWVzGAMgAygLMi0udGVuc29yYm9hcmQuRGV2aWNlU3RlcFN0YXRzLlRo" + "cmVhZE5hbWVzRW50cnkaMgoQVGhyZWFkTmFtZXNFbnRyeRILCgNrZXkYASAB" + "KA0SDQoFdmFsdWUYAiABKAk6AjgBIjwKCVN0ZXBTdGF0cxIvCglkZXZfc3Rh" + "dHMYASADKAsyHC50ZW5zb3Jib2FyZC5EZXZpY2VTdGVwU3RhdHNCgwEKGG9y" + "Zy50ZW5zb3JmbG93LmZyYW1ld29ya0IPU3RlcFN0YXRzUHJvdG9zUAFaUWdp" + "dGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28v" + "Y29yZS9mcmFtZXdvcmsvc3RlcF9zdGF0c19nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[2]
			{
				AllocationDescriptionReflection.Descriptor,
				TensorDescriptionReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[7]
			{
				new GeneratedClrTypeInfo(typeof(AllocationRecord), (MessageParser)(object)AllocationRecord.Parser, new string[2] { "AllocMicros", "AllocBytes" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(AllocatorMemoryUsed), (MessageParser)(object)AllocatorMemoryUsed.Parser, new string[6] { "AllocatorName", "TotalBytes", "PeakBytes", "LiveBytes", "AllocationRecords", "AllocatorBytesInUse" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(NodeOutput), (MessageParser)(object)NodeOutput.Parser, new string[2] { "Slot", "TensorDescription" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(MemoryStats), (MessageParser)(object)MemoryStats.Parser, new string[6] { "TempMemorySize", "PersistentMemorySize", "PersistentTensorAllocIds", "DeviceTempMemorySize", "DevicePersistentMemorySize", "DevicePersistentTensorAllocIds" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(NodeExecStats), (MessageParser)(object)NodeExecStats.Parser, new string[17]
				{
					"NodeName", "AllStartMicros", "OpStartRelMicros", "OpEndRelMicros", "AllEndRelMicros", "Memory", "Output", "TimelineLabel", "ScheduledMicros", "ThreadId",
					"ReferencedTensor", "MemoryStats", "AllStartNanos", "OpStartRelNanos", "OpEndRelNanos", "AllEndRelNanos", "ScheduledNanos"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(DeviceStepStats), (MessageParser)(object)DeviceStepStats.Parser, new string[3] { "Device", "NodeStats", "ThreadNames" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(StepStats), (MessageParser)(object)StepStats.Parser, new string[1] { "DevStats" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class AllocationRecord : IMessage<AllocationRecord>, IMessage, IEquatable<AllocationRecord>, IDeepCloneable<AllocationRecord>
	{
		private static readonly MessageParser<AllocationRecord> _parser = new MessageParser<AllocationRecord>((Func<AllocationRecord>)(() => new AllocationRecord()));

		private UnknownFieldSet _unknownFields;

		public const int AllocMicrosFieldNumber = 1;

		private long allocMicros_;

		public const int AllocBytesFieldNumber = 2;

		private long allocBytes_;

		[DebuggerNonUserCode]
		public static MessageParser<AllocationRecord> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long AllocMicros
		{
			get
			{
				return allocMicros_;
			}
			set
			{
				allocMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllocBytes
		{
			get
			{
				return allocBytes_;
			}
			set
			{
				allocBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public AllocationRecord()
		{
		}

		[DebuggerNonUserCode]
		public AllocationRecord(AllocationRecord other)
			: this()
		{
			allocMicros_ = other.allocMicros_;
			allocBytes_ = other.allocBytes_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public AllocationRecord Clone()
		{
			return new AllocationRecord(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as AllocationRecord);
		}

		[DebuggerNonUserCode]
		public bool Equals(AllocationRecord other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (AllocMicros != other.AllocMicros)
			{
				return false;
			}
			if (AllocBytes != other.AllocBytes)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (AllocMicros != 0L)
			{
				num ^= AllocMicros.GetHashCode();
			}
			if (AllocBytes != 0L)
			{
				num ^= AllocBytes.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (AllocMicros != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(AllocMicros);
			}
			if (AllocBytes != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(AllocBytes);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (AllocMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllocMicros);
			}
			if (AllocBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllocBytes);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(AllocationRecord other)
		{
			if (other != null)
			{
				if (other.AllocMicros != 0L)
				{
					AllocMicros = other.AllocMicros;
				}
				if (other.AllocBytes != 0L)
				{
					AllocBytes = other.AllocBytes;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					AllocMicros = input.ReadInt64();
					break;
				case 16u:
					AllocBytes = input.ReadInt64();
					break;
				}
			}
		}
	}
	public sealed class AllocatorMemoryUsed : IMessage<AllocatorMemoryUsed>, IMessage, IEquatable<AllocatorMemoryUsed>, IDeepCloneable<AllocatorMemoryUsed>
	{
		private static readonly MessageParser<AllocatorMemoryUsed> _parser = new MessageParser<AllocatorMemoryUsed>((Func<AllocatorMemoryUsed>)(() => new AllocatorMemoryUsed()));

		private UnknownFieldSet _unknownFields;

		public const int AllocatorNameFieldNumber = 1;

		private string allocatorName_ = "";

		public const int TotalBytesFieldNumber = 2;

		private long totalBytes_;

		public const int PeakBytesFieldNumber = 3;

		private long peakBytes_;

		public const int LiveBytesFieldNumber = 4;

		private long liveBytes_;

		public const int AllocationRecordsFieldNumber = 6;

		private static readonly FieldCodec<AllocationRecord> _repeated_allocationRecords_codec = FieldCodec.ForMessage<AllocationRecord>(50u, AllocationRecord.Parser);

		private readonly RepeatedField<AllocationRecord> allocationRecords_ = new RepeatedField<AllocationRecord>();

		public const int AllocatorBytesInUseFieldNumber = 5;

		private long allocatorBytesInUse_;

		[DebuggerNonUserCode]
		public static MessageParser<AllocatorMemoryUsed> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string AllocatorName
		{
			get
			{
				return allocatorName_;
			}
			set
			{
				allocatorName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long TotalBytes
		{
			get
			{
				return totalBytes_;
			}
			set
			{
				totalBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long PeakBytes
		{
			get
			{
				return peakBytes_;
			}
			set
			{
				peakBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long LiveBytes
		{
			get
			{
				return liveBytes_;
			}
			set
			{
				liveBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<AllocationRecord> AllocationRecords => allocationRecords_;

		[DebuggerNonUserCode]
		public long AllocatorBytesInUse
		{
			get
			{
				return allocatorBytesInUse_;
			}
			set
			{
				allocatorBytesInUse_ = value;
			}
		}

		[DebuggerNonUserCode]
		public AllocatorMemoryUsed()
		{
		}

		[DebuggerNonUserCode]
		public AllocatorMemoryUsed(AllocatorMemoryUsed other)
			: this()
		{
			allocatorName_ = other.allocatorName_;
			totalBytes_ = other.totalBytes_;
			peakBytes_ = other.peakBytes_;
			liveBytes_ = other.liveBytes_;
			allocationRecords_ = other.allocationRecords_.Clone();
			allocatorBytesInUse_ = other.allocatorBytesInUse_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public AllocatorMemoryUsed Clone()
		{
			return new AllocatorMemoryUsed(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as AllocatorMemoryUsed);
		}

		[DebuggerNonUserCode]
		public bool Equals(AllocatorMemoryUsed other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (AllocatorName != other.AllocatorName)
			{
				return false;
			}
			if (TotalBytes != other.TotalBytes)
			{
				return false;
			}
			if (PeakBytes != other.PeakBytes)
			{
				return false;
			}
			if (LiveBytes != other.LiveBytes)
			{
				return false;
			}
			if (!allocationRecords_.Equals(other.allocationRecords_))
			{
				return false;
			}
			if (AllocatorBytesInUse != other.AllocatorBytesInUse)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (AllocatorName.Length != 0)
			{
				num ^= AllocatorName.GetHashCode();
			}
			if (TotalBytes != 0L)
			{
				num ^= TotalBytes.GetHashCode();
			}
			if (PeakBytes != 0L)
			{
				num ^= PeakBytes.GetHashCode();
			}
			if (LiveBytes != 0L)
			{
				num ^= LiveBytes.GetHashCode();
			}
			num ^= ((object)allocationRecords_).GetHashCode();
			if (AllocatorBytesInUse != 0L)
			{
				num ^= AllocatorBytesInUse.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (AllocatorName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(AllocatorName);
			}
			if (TotalBytes != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(TotalBytes);
			}
			if (PeakBytes != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(PeakBytes);
			}
			if (LiveBytes != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(LiveBytes);
			}
			if (AllocatorBytesInUse != 0L)
			{
				output.WriteRawTag((byte)40);
				output.WriteInt64(AllocatorBytesInUse);
			}
			allocationRecords_.WriteTo(output, _repeated_allocationRecords_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (AllocatorName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(AllocatorName);
			}
			if (TotalBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(TotalBytes);
			}
			if (PeakBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(PeakBytes);
			}
			if (LiveBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(LiveBytes);
			}
			num += allocationRecords_.CalculateSize(_repeated_allocationRecords_codec);
			if (AllocatorBytesInUse != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllocatorBytesInUse);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(AllocatorMemoryUsed other)
		{
			if (other != null)
			{
				if (other.AllocatorName.Length != 0)
				{
					AllocatorName = other.AllocatorName;
				}
				if (other.TotalBytes != 0L)
				{
					TotalBytes = other.TotalBytes;
				}
				if (other.PeakBytes != 0L)
				{
					PeakBytes = other.PeakBytes;
				}
				if (other.LiveBytes != 0L)
				{
					LiveBytes = other.LiveBytes;
				}
				allocationRecords_.Add((IEnumerable<AllocationRecord>)other.allocationRecords_);
				if (other.AllocatorBytesInUse != 0L)
				{
					AllocatorBytesInUse = other.AllocatorBytesInUse;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					AllocatorName = input.ReadString();
					break;
				case 16u:
					TotalBytes = input.ReadInt64();
					break;
				case 24u:
					PeakBytes = input.ReadInt64();
					break;
				case 32u:
					LiveBytes = input.ReadInt64();
					break;
				case 40u:
					AllocatorBytesInUse = input.ReadInt64();
					break;
				case 50u:
					allocationRecords_.AddEntriesFrom(input, _repeated_allocationRecords_codec);
					break;
				}
			}
		}
	}
	public sealed class NodeOutput : IMessage<NodeOutput>, IMessage, IEquatable<NodeOutput>, IDeepCloneable<NodeOutput>
	{
		private static readonly MessageParser<NodeOutput> _parser = new MessageParser<NodeOutput>((Func<NodeOutput>)(() => new NodeOutput()));

		private UnknownFieldSet _unknownFields;

		public const int SlotFieldNumber = 1;

		private int slot_;

		public const int TensorDescriptionFieldNumber = 3;

		private TensorDescription tensorDescription_;

		[DebuggerNonUserCode]
		public static MessageParser<NodeOutput> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int Slot
		{
			get
			{
				return slot_;
			}
			set
			{
				slot_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorDescription TensorDescription
		{
			get
			{
				return tensorDescription_;
			}
			set
			{
				tensorDescription_ = value;
			}
		}

		[DebuggerNonUserCode]
		public NodeOutput()
		{
		}

		[DebuggerNonUserCode]
		public NodeOutput(NodeOutput other)
			: this()
		{
			slot_ = other.slot_;
			tensorDescription_ = ((other.tensorDescription_ != null) ? other.tensorDescription_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public NodeOutput Clone()
		{
			return new NodeOutput(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as NodeOutput);
		}

		[DebuggerNonUserCode]
		public bool Equals(NodeOutput other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Slot != other.Slot)
			{
				return false;
			}
			if (!object.Equals(TensorDescription, other.TensorDescription))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Slot != 0)
			{
				num ^= Slot.GetHashCode();
			}
			if (tensorDescription_ != null)
			{
				num ^= TensorDescription.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Slot != 0)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt32(Slot);
			}
			if (tensorDescription_ != null)
			{
				output.WriteRawTag((byte)26);
				output.WriteMessage((IMessage)(object)TensorDescription);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Slot != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Slot);
			}
			if (tensorDescription_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TensorDescription);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(NodeOutput other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Slot != 0)
			{
				Slot = other.Slot;
			}
			if (other.tensorDescription_ != null)
			{
				if (tensorDescription_ == null)
				{
					TensorDescription = new TensorDescription();
				}
				TensorDescription.MergeFrom(other.TensorDescription);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Slot = input.ReadInt32();
					break;
				case 26u:
					if (tensorDescription_ == null)
					{
						TensorDescription = new TensorDescription();
					}
					input.ReadMessage((IMessage)(object)TensorDescription);
					break;
				}
			}
		}
	}
	public sealed class MemoryStats : IMessage<MemoryStats>, IMessage, IEquatable<MemoryStats>, IDeepCloneable<MemoryStats>
	{
		private static readonly MessageParser<MemoryStats> _parser = new MessageParser<MemoryStats>((Func<MemoryStats>)(() => new MemoryStats()));

		private UnknownFieldSet _unknownFields;

		public const int TempMemorySizeFieldNumber = 1;

		private long tempMemorySize_;

		public const int PersistentMemorySizeFieldNumber = 3;

		private long persistentMemorySize_;

		public const int PersistentTensorAllocIdsFieldNumber = 5;

		private static readonly FieldCodec<long> _repeated_persistentTensorAllocIds_codec = FieldCodec.ForInt64(42u);

		private readonly RepeatedField<long> persistentTensorAllocIds_ = new RepeatedField<long>();

		public const int DeviceTempMemorySizeFieldNumber = 2;

		private long deviceTempMemorySize_;

		public const int DevicePersistentMemorySizeFieldNumber = 4;

		private long devicePersistentMemorySize_;

		public const int DevicePersistentTensorAllocIdsFieldNumber = 6;

		private static readonly FieldCodec<long> _repeated_devicePersistentTensorAllocIds_codec = FieldCodec.ForInt64(50u);

		private readonly RepeatedField<long> devicePersistentTensorAllocIds_ = new RepeatedField<long>();

		[DebuggerNonUserCode]
		public static MessageParser<MemoryStats> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long TempMemorySize
		{
			get
			{
				return tempMemorySize_;
			}
			set
			{
				tempMemorySize_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long PersistentMemorySize
		{
			get
			{
				return persistentMemorySize_;
			}
			set
			{
				persistentMemorySize_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<long> PersistentTensorAllocIds => persistentTensorAllocIds_;

		[Obsolete]
		[DebuggerNonUserCode]
		public long DeviceTempMemorySize
		{
			get
			{
				return deviceTempMemorySize_;
			}
			set
			{
				deviceTempMemorySize_ = value;
			}
		}

		[Obsolete]
		[DebuggerNonUserCode]
		public long DevicePersistentMemorySize
		{
			get
			{
				return devicePersistentMemorySize_;
			}
			set
			{
				devicePersistentMemorySize_ = value;
			}
		}

		[Obsolete]
		[DebuggerNonUserCode]
		public RepeatedField<long> DevicePersistentTensorAllocIds => devicePersistentTensorAllocIds_;

		[DebuggerNonUserCode]
		public MemoryStats()
		{
		}

		[DebuggerNonUserCode]
		public MemoryStats(MemoryStats other)
			: this()
		{
			tempMemorySize_ = other.tempMemorySize_;
			persistentMemorySize_ = other.persistentMemorySize_;
			persistentTensorAllocIds_ = other.persistentTensorAllocIds_.Clone();
			deviceTempMemorySize_ = other.deviceTempMemorySize_;
			devicePersistentMemorySize_ = other.devicePersistentMemorySize_;
			devicePersistentTensorAllocIds_ = other.devicePersistentTensorAllocIds_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public MemoryStats Clone()
		{
			return new MemoryStats(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as MemoryStats);
		}

		[DebuggerNonUserCode]
		public bool Equals(MemoryStats other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TempMemorySize != other.TempMemorySize)
			{
				return false;
			}
			if (PersistentMemorySize != other.PersistentMemorySize)
			{
				return false;
			}
			if (!persistentTensorAllocIds_.Equals(other.persistentTensorAllocIds_))
			{
				return false;
			}
			if (DeviceTempMemorySize != other.DeviceTempMemorySize)
			{
				return false;
			}
			if (DevicePersistentMemorySize != other.DevicePersistentMemorySize)
			{
				return false;
			}
			if (!devicePersistentTensorAllocIds_.Equals(other.devicePersistentTensorAllocIds_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TempMemorySize != 0L)
			{
				num ^= TempMemorySize.GetHashCode();
			}
			if (PersistentMemorySize != 0L)
			{
				num ^= PersistentMemorySize.GetHashCode();
			}
			num ^= ((object)persistentTensorAllocIds_).GetHashCode();
			if (DeviceTempMemorySize != 0L)
			{
				num ^= DeviceTempMemorySize.GetHashCode();
			}
			if (DevicePersistentMemorySize != 0L)
			{
				num ^= DevicePersistentMemorySize.GetHashCode();
			}
			num ^= ((object)devicePersistentTensorAllocIds_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TempMemorySize != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(TempMemorySize);
			}
			if (DeviceTempMemorySize != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(DeviceTempMemorySize);
			}
			if (PersistentMemorySize != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(PersistentMemorySize);
			}
			if (DevicePersistentMemorySize != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(DevicePersistentMemorySize);
			}
			persistentTensorAllocIds_.WriteTo(output, _repeated_persistentTensorAllocIds_codec);
			devicePersistentTensorAllocIds_.WriteTo(output, _repeated_devicePersistentTensorAllocIds_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TempMemorySize != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(TempMemorySize);
			}
			if (PersistentMemorySize != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(PersistentMemorySize);
			}
			num += persistentTensorAllocIds_.CalculateSize(_repeated_persistentTensorAllocIds_codec);
			if (DeviceTempMemorySize != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(DeviceTempMemorySize);
			}
			if (DevicePersistentMemorySize != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(DevicePersistentMemorySize);
			}
			num += devicePersistentTensorAllocIds_.CalculateSize(_repeated_devicePersistentTensorAllocIds_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(MemoryStats other)
		{
			if (other != null)
			{
				if (other.TempMemorySize != 0L)
				{
					TempMemorySize = other.TempMemorySize;
				}
				if (other.PersistentMemorySize != 0L)
				{
					PersistentMemorySize = other.PersistentMemorySize;
				}
				persistentTensorAllocIds_.Add((IEnumerable<long>)other.persistentTensorAllocIds_);
				if (other.DeviceTempMemorySize != 0L)
				{
					DeviceTempMemorySize = other.DeviceTempMemorySize;
				}
				if (other.DevicePersistentMemorySize != 0L)
				{
					DevicePersistentMemorySize = other.DevicePersistentMemorySize;
				}
				devicePersistentTensorAllocIds_.Add((IEnumerable<long>)other.devicePersistentTensorAllocIds_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					TempMemorySize = input.ReadInt64();
					break;
				case 16u:
					DeviceTempMemorySize = input.ReadInt64();
					break;
				case 24u:
					PersistentMemorySize = input.ReadInt64();
					break;
				case 32u:
					DevicePersistentMemorySize = input.ReadInt64();
					break;
				case 40u:
				case 42u:
					persistentTensorAllocIds_.AddEntriesFrom(input, _repeated_persistentTensorAllocIds_codec);
					break;
				case 48u:
				case 50u:
					devicePersistentTensorAllocIds_.AddEntriesFrom(input, _repeated_devicePersistentTensorAllocIds_codec);
					break;
				}
			}
		}
	}
	public sealed class NodeExecStats : IMessage<NodeExecStats>, IMessage, IEquatable<NodeExecStats>, IDeepCloneable<NodeExecStats>
	{
		private static readonly MessageParser<NodeExecStats> _parser = new MessageParser<NodeExecStats>((Func<NodeExecStats>)(() => new NodeExecStats()));

		private UnknownFieldSet _unknownFields;

		public const int NodeNameFieldNumber = 1;

		private string nodeName_ = "";

		public const int AllStartMicrosFieldNumber = 2;

		private long allStartMicros_;

		public const int OpStartRelMicrosFieldNumber = 3;

		private long opStartRelMicros_;

		public const int OpEndRelMicrosFieldNumber = 4;

		private long opEndRelMicros_;

		public const int AllEndRelMicrosFieldNumber = 5;

		private long allEndRelMicros_;

		public const int MemoryFieldNumber = 6;

		private static readonly FieldCodec<AllocatorMemoryUsed> _repeated_memory_codec = FieldCodec.ForMessage<AllocatorMemoryUsed>(50u, AllocatorMemoryUsed.Parser);

		private readonly RepeatedField<AllocatorMemoryUsed> memory_ = new RepeatedField<AllocatorMemoryUsed>();

		public const int OutputFieldNumber = 7;

		private static readonly FieldCodec<NodeOutput> _repeated_output_codec = FieldCodec.ForMessage<NodeOutput>(58u, NodeOutput.Parser);

		private readonly RepeatedField<NodeOutput> output_ = new RepeatedField<NodeOutput>();

		public const int TimelineLabelFieldNumber = 8;

		private string timelineLabel_ = "";

		public const int ScheduledMicrosFieldNumber = 9;

		private long scheduledMicros_;

		public const int ThreadIdFieldNumber = 10;

		private uint threadId_;

		public const int ReferencedTensorFieldNumber = 11;

		private static readonly FieldCodec<AllocationDescription> _repeated_referencedTensor_codec = FieldCodec.ForMessage<AllocationDescription>(90u, AllocationDescription.Parser);

		private readonly RepeatedField<AllocationDescription> referencedTensor_ = new RepeatedField<AllocationDescription>();

		public const int MemoryStatsFieldNumber = 12;

		private MemoryStats memoryStats_;

		public const int AllStartNanosFieldNumber = 13;

		private long allStartNanos_;

		public const int OpStartRelNanosFieldNumber = 14;

		private long opStartRelNanos_;

		public const int OpEndRelNanosFieldNumber = 15;

		private long opEndRelNanos_;

		public const int AllEndRelNanosFieldNumber = 16;

		private long allEndRelNanos_;

		public const int ScheduledNanosFieldNumber = 17;

		private long scheduledNanos_;

		[DebuggerNonUserCode]
		public static MessageParser<NodeExecStats> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string NodeName
		{
			get
			{
				return nodeName_;
			}
			set
			{
				nodeName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long AllStartMicros
		{
			get
			{
				return allStartMicros_;
			}
			set
			{
				allStartMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long OpStartRelMicros
		{
			get
			{
				return opStartRelMicros_;
			}
			set
			{
				opStartRelMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long OpEndRelMicros
		{
			get
			{
				return opEndRelMicros_;
			}
			set
			{
				opEndRelMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllEndRelMicros
		{
			get
			{
				return allEndRelMicros_;
			}
			set
			{
				allEndRelMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<AllocatorMemoryUsed> Memory => memory_;

		[DebuggerNonUserCode]
		public RepeatedField<NodeOutput> Output => output_;

		[DebuggerNonUserCode]
		public string TimelineLabel
		{
			get
			{
				return timelineLabel_;
			}
			set
			{
				timelineLabel_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long ScheduledMicros
		{
			get
			{
				return scheduledMicros_;
			}
			set
			{
				scheduledMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public uint ThreadId
		{
			get
			{
				return threadId_;
			}
			set
			{
				threadId_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<AllocationDescription> ReferencedTensor => referencedTensor_;

		[DebuggerNonUserCode]
		public MemoryStats MemoryStats
		{
			get
			{
				return memoryStats_;
			}
			set
			{
				memoryStats_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllStartNanos
		{
			get
			{
				return allStartNanos_;
			}
			set
			{
				allStartNanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long OpStartRelNanos
		{
			get
			{
				return opStartRelNanos_;
			}
			set
			{
				opStartRelNanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long OpEndRelNanos
		{
			get
			{
				return opEndRelNanos_;
			}
			set
			{
				opEndRelNanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllEndRelNanos
		{
			get
			{
				return allEndRelNanos_;
			}
			set
			{
				allEndRelNanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long ScheduledNanos
		{
			get
			{
				return scheduledNanos_;
			}
			set
			{
				scheduledNanos_ = value;
			}
		}

		[DebuggerNonUserCode]
		public NodeExecStats()
		{
		}

		[DebuggerNonUserCode]
		public NodeExecStats(NodeExecStats other)
			: this()
		{
			nodeName_ = other.nodeName_;
			allStartMicros_ = other.allStartMicros_;
			opStartRelMicros_ = other.opStartRelMicros_;
			opEndRelMicros_ = other.opEndRelMicros_;
			allEndRelMicros_ = other.allEndRelMicros_;
			memory_ = other.memory_.Clone();
			output_ = other.output_.Clone();
			timelineLabel_ = other.timelineLabel_;
			scheduledMicros_ = other.scheduledMicros_;
			threadId_ = other.threadId_;
			referencedTensor_ = other.referencedTensor_.Clone();
			memoryStats_ = ((other.memoryStats_ != null) ? other.memoryStats_.Clone() : null);
			allStartNanos_ = other.allStartNanos_;
			opStartRelNanos_ = other.opStartRelNanos_;
			opEndRelNanos_ = other.opEndRelNanos_;
			allEndRelNanos_ = other.allEndRelNanos_;
			scheduledNanos_ = other.scheduledNanos_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public NodeExecStats Clone()
		{
			return new NodeExecStats(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as NodeExecStats);
		}

		[DebuggerNonUserCode]
		public bool Equals(NodeExecStats other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (NodeName != other.NodeName)
			{
				return false;
			}
			if (AllStartMicros != other.AllStartMicros)
			{
				return false;
			}
			if (OpStartRelMicros != other.OpStartRelMicros)
			{
				return false;
			}
			if (OpEndRelMicros != other.OpEndRelMicros)
			{
				return false;
			}
			if (AllEndRelMicros != other.AllEndRelMicros)
			{
				return false;
			}
			if (!memory_.Equals(other.memory_))
			{
				return false;
			}
			if (!output_.Equals(other.output_))
			{
				return false;
			}
			if (TimelineLabel != other.TimelineLabel)
			{
				return false;
			}
			if (ScheduledMicros != other.ScheduledMicros)
			{
				return false;
			}
			if (ThreadId != other.ThreadId)
			{
				return false;
			}
			if (!referencedTensor_.Equals(other.referencedTensor_))
			{
				return false;
			}
			if (!object.Equals(MemoryStats, other.MemoryStats))
			{
				return false;
			}
			if (AllStartNanos != other.AllStartNanos)
			{
				return false;
			}
			if (OpStartRelNanos != other.OpStartRelNanos)
			{
				return false;
			}
			if (OpEndRelNanos != other.OpEndRelNanos)
			{
				return false;
			}
			if (AllEndRelNanos != other.AllEndRelNanos)
			{
				return false;
			}
			if (ScheduledNanos != other.ScheduledNanos)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (NodeName.Length != 0)
			{
				num ^= NodeName.GetHashCode();
			}
			if (AllStartMicros != 0L)
			{
				num ^= AllStartMicros.GetHashCode();
			}
			if (OpStartRelMicros != 0L)
			{
				num ^= OpStartRelMicros.GetHashCode();
			}
			if (OpEndRelMicros != 0L)
			{
				num ^= OpEndRelMicros.GetHashCode();
			}
			if (AllEndRelMicros != 0L)
			{
				num ^= AllEndRelMicros.GetHashCode();
			}
			num ^= ((object)memory_).GetHashCode();
			num ^= ((object)output_).GetHashCode();
			if (TimelineLabel.Length != 0)
			{
				num ^= TimelineLabel.GetHashCode();
			}
			if (ScheduledMicros != 0L)
			{
				num ^= ScheduledMicros.GetHashCode();
			}
			if (ThreadId != 0)
			{
				num ^= ThreadId.GetHashCode();
			}
			num ^= ((object)referencedTensor_).GetHashCode();
			if (memoryStats_ != null)
			{
				num ^= MemoryStats.GetHashCode();
			}
			if (AllStartNanos != 0L)
			{
				num ^= AllStartNanos.GetHashCode();
			}
			if (OpStartRelNanos != 0L)
			{
				num ^= OpStartRelNanos.GetHashCode();
			}
			if (OpEndRelNanos != 0L)
			{
				num ^= OpEndRelNanos.GetHashCode();
			}
			if (AllEndRelNanos != 0L)
			{
				num ^= AllEndRelNanos.GetHashCode();
			}
			if (ScheduledNanos != 0L)
			{
				num ^= ScheduledNanos.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (NodeName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(NodeName);
			}
			if (AllStartMicros != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(AllStartMicros);
			}
			if (OpStartRelMicros != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(OpStartRelMicros);
			}
			if (OpEndRelMicros != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(OpEndRelMicros);
			}
			if (AllEndRelMicros != 0L)
			{
				output.WriteRawTag((byte)40);
				output.WriteInt64(AllEndRelMicros);
			}
			memory_.WriteTo(output, _repeated_memory_codec);
			output_.WriteTo(output, _repeated_output_codec);
			if (TimelineLabel.Length != 0)
			{
				output.WriteRawTag((byte)66);
				output.WriteString(TimelineLabel);
			}
			if (ScheduledMicros != 0L)
			{
				output.WriteRawTag((byte)72);
				output.WriteInt64(ScheduledMicros);
			}
			if (ThreadId != 0)
			{
				output.WriteRawTag((byte)80);
				output.WriteUInt32(ThreadId);
			}
			referencedTensor_.WriteTo(output, _repeated_referencedTensor_codec);
			if (memoryStats_ != null)
			{
				output.WriteRawTag((byte)98);
				output.WriteMessage((IMessage)(object)MemoryStats);
			}
			if (AllStartNanos != 0L)
			{
				output.WriteRawTag((byte)104);
				output.WriteInt64(AllStartNanos);
			}
			if (OpStartRelNanos != 0L)
			{
				output.WriteRawTag((byte)112);
				output.WriteInt64(OpStartRelNanos);
			}
			if (OpEndRelNanos != 0L)
			{
				output.WriteRawTag((byte)120);
				output.WriteInt64(OpEndRelNanos);
			}
			if (AllEndRelNanos != 0L)
			{
				output.WriteRawTag((byte)128, (byte)1);
				output.WriteInt64(AllEndRelNanos);
			}
			if (ScheduledNanos != 0L)
			{
				output.WriteRawTag((byte)136, (byte)1);
				output.WriteInt64(ScheduledNanos);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (NodeName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(NodeName);
			}
			if (AllStartMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllStartMicros);
			}
			if (OpStartRelMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(OpStartRelMicros);
			}
			if (OpEndRelMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(OpEndRelMicros);
			}
			if (AllEndRelMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllEndRelMicros);
			}
			num += memory_.CalculateSize(_repeated_memory_codec);
			num += output_.CalculateSize(_repeated_output_codec);
			if (TimelineLabel.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TimelineLabel);
			}
			if (ScheduledMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(ScheduledMicros);
			}
			if (ThreadId != 0)
			{
				num += 1 + CodedOutputStream.ComputeUInt32Size(ThreadId);
			}
			num += referencedTensor_.CalculateSize(_repeated_referencedTensor_codec);
			if (memoryStats_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)MemoryStats);
			}
			if (AllStartNanos != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllStartNanos);
			}
			if (OpStartRelNanos != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(OpStartRelNanos);
			}
			if (OpEndRelNanos != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(OpEndRelNanos);
			}
			if (AllEndRelNanos != 0L)
			{
				num += 2 + CodedOutputStream.ComputeInt64Size(AllEndRelNanos);
			}
			if (ScheduledNanos != 0L)
			{
				num += 2 + CodedOutputStream.ComputeInt64Size(ScheduledNanos);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(NodeExecStats other)
		{
			if (other == null)
			{
				return;
			}
			if (other.NodeName.Length != 0)
			{
				NodeName = other.NodeName;
			}
			if (other.AllStartMicros != 0L)
			{
				AllStartMicros = other.AllStartMicros;
			}
			if (other.OpStartRelMicros != 0L)
			{
				OpStartRelMicros = other.OpStartRelMicros;
			}
			if (other.OpEndRelMicros != 0L)
			{
				OpEndRelMicros = other.OpEndRelMicros;
			}
			if (other.AllEndRelMicros != 0L)
			{
				AllEndRelMicros = other.AllEndRelMicros;
			}
			memory_.Add((IEnumerable<AllocatorMemoryUsed>)other.memory_);
			output_.Add((IEnumerable<NodeOutput>)other.output_);
			if (other.TimelineLabel.Length != 0)
			{
				TimelineLabel = other.TimelineLabel;
			}
			if (other.ScheduledMicros != 0L)
			{
				ScheduledMicros = other.ScheduledMicros;
			}
			if (other.ThreadId != 0)
			{
				ThreadId = other.ThreadId;
			}
			referencedTensor_.Add((IEnumerable<AllocationDescription>)other.referencedTensor_);
			if (other.memoryStats_ != null)
			{
				if (memoryStats_ == null)
				{
					MemoryStats = new MemoryStats();
				}
				MemoryStats.MergeFrom(other.MemoryStats);
			}
			if (other.AllStartNanos != 0L)
			{
				AllStartNanos = other.AllStartNanos;
			}
			if (other.OpStartRelNanos != 0L)
			{
				OpStartRelNanos = other.OpStartRelNanos;
			}
			if (other.OpEndRelNanos != 0L)
			{
				OpEndRelNanos = other.OpEndRelNanos;
			}
			if (other.AllEndRelNanos != 0L)
			{
				AllEndRelNanos = other.AllEndRelNanos;
			}
			if (other.ScheduledNanos != 0L)
			{
				ScheduledNanos = other.ScheduledNanos;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					NodeName = input.ReadString();
					break;
				case 16u:
					AllStartMicros = input.ReadInt64();
					break;
				case 24u:
					OpStartRelMicros = input.ReadInt64();
					break;
				case 32u:
					OpEndRelMicros = input.ReadInt64();
					break;
				case 40u:
					AllEndRelMicros = input.ReadInt64();
					break;
				case 50u:
					memory_.AddEntriesFrom(input, _repeated_memory_codec);
					break;
				case 58u:
					output_.AddEntriesFrom(input, _repeated_output_codec);
					break;
				case 66u:
					TimelineLabel = input.ReadString();
					break;
				case 72u:
					ScheduledMicros = input.ReadInt64();
					break;
				case 80u:
					ThreadId = input.ReadUInt32();
					break;
				case 90u:
					referencedTensor_.AddEntriesFrom(input, _repeated_referencedTensor_codec);
					break;
				case 98u:
					if (memoryStats_ == null)
					{
						MemoryStats = new MemoryStats();
					}
					input.ReadMessage((IMessage)(object)MemoryStats);
					break;
				case 104u:
					AllStartNanos = input.ReadInt64();
					break;
				case 112u:
					OpStartRelNanos = input.ReadInt64();
					break;
				case 120u:
					OpEndRelNanos = input.ReadInt64();
					break;
				case 128u:
					AllEndRelNanos = input.ReadInt64();
					break;
				case 136u:
					ScheduledNanos = input.ReadInt64();
					break;
				}
			}
		}
	}
	public sealed class DeviceStepStats : IMessage<DeviceStepStats>, IMessage, IEquatable<DeviceStepStats>, IDeepCloneable<DeviceStepStats>
	{
		private static readonly MessageParser<DeviceStepStats> _parser = new MessageParser<DeviceStepStats>((Func<DeviceStepStats>)(() => new DeviceStepStats()));

		private UnknownFieldSet _unknownFields;

		public const int DeviceFieldNumber = 1;

		private string device_ = "";

		public const int NodeStatsFieldNumber = 2;

		private static readonly FieldCodec<NodeExecStats> _repeated_nodeStats_codec = FieldCodec.ForMessage<NodeExecStats>(18u, NodeExecStats.Parser);

		private readonly RepeatedField<NodeExecStats> nodeStats_ = new RepeatedField<NodeExecStats>();

		public const int ThreadNamesFieldNumber = 3;

		private static readonly Codec<uint, string> _map_threadNames_codec = new Codec<uint, string>(FieldCodec.ForUInt32(8u, 0u), FieldCodec.ForString(18u, ""), 26u);

		private readonly MapField<uint, string> threadNames_ = new MapField<uint, string>();

		[DebuggerNonUserCode]
		public static MessageParser<DeviceStepStats> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Device
		{
			get
			{
				return device_;
			}
			set
			{
				device_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<NodeExecStats> NodeStats => nodeStats_;

		[DebuggerNonUserCode]
		public MapField<uint, string> ThreadNames => threadNames_;

		[DebuggerNonUserCode]
		public DeviceStepStats()
		{
		}

		[DebuggerNonUserCode]
		public DeviceStepStats(DeviceStepStats other)
			: this()
		{
			device_ = other.device_;
			nodeStats_ = other.nodeStats_.Clone();
			threadNames_ = other.threadNames_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public DeviceStepStats Clone()
		{
			return new DeviceStepStats(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as DeviceStepStats);
		}

		[DebuggerNonUserCode]
		public bool Equals(DeviceStepStats other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Device != other.Device)
			{
				return false;
			}
			if (!nodeStats_.Equals(other.nodeStats_))
			{
				return false;
			}
			if (!ThreadNames.Equals(other.ThreadNames))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Device.Length != 0)
			{
				num ^= Device.GetHashCode();
			}
			num ^= ((object)nodeStats_).GetHashCode();
			num ^= ((object)ThreadNames).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Device.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Device);
			}
			nodeStats_.WriteTo(output, _repeated_nodeStats_codec);
			threadNames_.WriteTo(output, _map_threadNames_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Device.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Device);
			}
			num += nodeStats_.CalculateSize(_repeated_nodeStats_codec);
			num += threadNames_.CalculateSize(_map_threadNames_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(DeviceStepStats other)
		{
			if (other != null)
			{
				if (other.Device.Length != 0)
				{
					Device = other.Device;
				}
				nodeStats_.Add((IEnumerable<NodeExecStats>)other.nodeStats_);
				threadNames_.Add((IDictionary<uint, string>)other.threadNames_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Device = input.ReadString();
					break;
				case 18u:
					nodeStats_.AddEntriesFrom(input, _repeated_nodeStats_codec);
					break;
				case 26u:
					threadNames_.AddEntriesFrom(input, _map_threadNames_codec);
					break;
				}
			}
		}
	}
	public sealed class StepStats : IMessage<StepStats>, IMessage, IEquatable<StepStats>, IDeepCloneable<StepStats>
	{
		private static readonly MessageParser<StepStats> _parser = new MessageParser<StepStats>((Func<StepStats>)(() => new StepStats()));

		private UnknownFieldSet _unknownFields;

		public const int DevStatsFieldNumber = 1;

		private static readonly FieldCodec<DeviceStepStats> _repeated_devStats_codec = FieldCodec.ForMessage<DeviceStepStats>(10u, DeviceStepStats.Parser);

		private readonly RepeatedField<DeviceStepStats> devStats_ = new RepeatedField<DeviceStepStats>();

		[DebuggerNonUserCode]
		public static MessageParser<StepStats> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StepStatsReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<DeviceStepStats> DevStats => devStats_;

		[DebuggerNonUserCode]
		public StepStats()
		{
		}

		[DebuggerNonUserCode]
		public StepStats(StepStats other)
			: this()
		{
			devStats_ = other.devStats_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public StepStats Clone()
		{
			return new StepStats(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as StepStats);
		}

		[DebuggerNonUserCode]
		public bool Equals(StepStats other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!devStats_.Equals(other.devStats_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)devStats_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			devStats_.WriteTo(output, _repeated_devStats_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += devStats_.CalculateSize(_repeated_devStats_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(StepStats other)
		{
			if (other != null)
			{
				devStats_.Add((IEnumerable<DeviceStepStats>)other.devStats_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					devStats_.AddEntriesFrom(input, _repeated_devStats_codec);
				}
			}
		}
	}
	public static class StructReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static StructReflection()
		{
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Expected O, but got Unknown
			//IL_02a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Expected O, but got Unknown
			//IL_02cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Expected O, but got Unknown
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Expected O, but got Unknown
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Expected O, but got Unknown
			//IL_0353: Unknown result type (might be due to invalid IL or missing references)
			//IL_0359: Expected O, but got Unknown
			//IL_0384: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Expected O, but got Unknown
			//IL_03bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c3: Expected O, but got Unknown
			//IL_0406: Unknown result type (might be due to invalid IL or missing references)
			//IL_040c: Expected O, but got Unknown
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Expected O, but got Unknown
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc3RydWN0LnByb3RvEgt0ZW5z" + "b3Jib2FyZBoldGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3RlbnNvci5wcm90" + "bxordGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3RlbnNvcl9zaGFwZS5wcm90" + "bxokdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3R5cGVzLnByb3RvIpoFCg9T" + "dHJ1Y3R1cmVkVmFsdWUSLAoKbm9uZV92YWx1ZRgBIAEoCzIWLnRlbnNvcmJv" + "YXJkLk5vbmVWYWx1ZUgAEhcKDWZsb2F0NjRfdmFsdWUYCyABKAFIABIVCgtp" + "bnQ2NF92YWx1ZRgMIAEoEkgAEhYKDHN0cmluZ192YWx1ZRgNIAEoCUgAEhQK" + "CmJvb2xfdmFsdWUYDiABKAhIABI7ChJ0ZW5zb3Jfc2hhcGVfdmFsdWUYHyAB" + "KAsyHS50ZW5zb3Jib2FyZC5UZW5zb3JTaGFwZVByb3RvSAASMwoSdGVuc29y" + "X2R0eXBlX3ZhbHVlGCAgASgOMhUudGVuc29yYm9hcmQuRGF0YVR5cGVIABI5" + "ChF0ZW5zb3Jfc3BlY192YWx1ZRghIAEoCzIcLnRlbnNvcmJvYXJkLlRlbnNv" + "clNwZWNQcm90b0gAEjUKD3R5cGVfc3BlY192YWx1ZRgiIAEoCzIaLnRlbnNv" + "cmJvYXJkLlR5cGVTcGVjUHJvdG9IABJIChlib3VuZGVkX3RlbnNvcl9zcGVj" + "X3ZhbHVlGCMgASgLMiMudGVuc29yYm9hcmQuQm91bmRlZFRlbnNvclNwZWNQ" + "cm90b0gAEiwKCmxpc3RfdmFsdWUYMyABKAsyFi50ZW5zb3Jib2FyZC5MaXN0" + "VmFsdWVIABIuCgt0dXBsZV92YWx1ZRg0IAEoCzIXLnRlbnNvcmJvYXJkLlR1" + "cGxlVmFsdWVIABIsCgpkaWN0X3ZhbHVlGDUgASgLMhYudGVuc29yYm9hcmQu" + "RGljdFZhbHVlSAASOQoRbmFtZWRfdHVwbGVfdmFsdWUYNiABKAsyHC50ZW5z" + "b3Jib2FyZC5OYW1lZFR1cGxlVmFsdWVIAEIGCgRraW5kIgsKCU5vbmVWYWx1" + "ZSI5CglMaXN0VmFsdWUSLAoGdmFsdWVzGAEgAygLMhwudGVuc29yYm9hcmQu" + "U3RydWN0dXJlZFZhbHVlIjoKClR1cGxlVmFsdWUSLAoGdmFsdWVzGAEgAygL" + "MhwudGVuc29yYm9hcmQuU3RydWN0dXJlZFZhbHVlIowBCglEaWN0VmFsdWUS" + "MgoGZmllbGRzGAEgAygLMiIudGVuc29yYm9hcmQuRGljdFZhbHVlLkZpZWxk" + "c0VudHJ5GksKC0ZpZWxkc0VudHJ5EgsKA2tleRgBIAEoCRIrCgV2YWx1ZRgC" + "IAEoCzIcLnRlbnNvcmJvYXJkLlN0cnVjdHVyZWRWYWx1ZToCOAEiRQoJUGFp" + "clZhbHVlEgsKA2tleRgBIAEoCRIrCgV2YWx1ZRgCIAEoCzIcLnRlbnNvcmJv" + "YXJkLlN0cnVjdHVyZWRWYWx1ZSJHCg9OYW1lZFR1cGxlVmFsdWUSDAoEbmFt" + "ZRgBIAEoCRImCgZ2YWx1ZXMYAiADKAsyFi50ZW5zb3Jib2FyZC5QYWlyVmFs" + "dWUicwoPVGVuc29yU3BlY1Byb3RvEgwKBG5hbWUYASABKAkSLAoFc2hhcGUY" + "AiABKAsyHS50ZW5zb3Jib2FyZC5UZW5zb3JTaGFwZVByb3RvEiQKBWR0eXBl" + "GAMgASgOMhUudGVuc29yYm9hcmQuRGF0YVR5cGUi0AEKFkJvdW5kZWRUZW5z" + "b3JTcGVjUHJvdG8SDAoEbmFtZRgBIAEoCRIsCgVzaGFwZRgCIAEoCzIdLnRl" + "bnNvcmJvYXJkLlRlbnNvclNoYXBlUHJvdG8SJAoFZHR5cGUYAyABKA4yFS50" + "ZW5zb3Jib2FyZC5EYXRhVHlwZRIpCgdtaW5pbXVtGAQgASgLMhgudGVuc29y" + "Ym9hcmQuVGVuc29yUHJvdG8SKQoHbWF4aW11bRgFIAEoCzIYLnRlbnNvcmJv" + "YXJkLlRlbnNvclByb3RvIvoDCg1UeXBlU3BlY1Byb3RvEkEKD3R5cGVfc3Bl" + "Y19jbGFzcxgBIAEoDjIoLnRlbnNvcmJvYXJkLlR5cGVTcGVjUHJvdG8uVHlw" + "ZVNwZWNDbGFzcxIwCgp0eXBlX3N0YXRlGAIgASgLMhwudGVuc29yYm9hcmQu" + "U3RydWN0dXJlZFZhbHVlEhwKFHR5cGVfc3BlY19jbGFzc19uYW1lGAMgASgJ" + "EhsKE251bV9mbGF0X2NvbXBvbmVudHMYBCABKAUiuAIKDVR5cGVTcGVjQ2xh" + "c3MSCwoHVU5LTk9XThAAEhYKElNQQVJTRV9URU5TT1JfU1BFQxABEhcKE0lO" + "REVYRURfU0xJQ0VTX1NQRUMQAhIWChJSQUdHRURfVEVOU09SX1NQRUMQAxIV" + "ChFURU5TT1JfQVJSQVlfU1BFQxAEEhUKEURBVEFfREFUQVNFVF9TUEVDEAUS" + "FgoSREFUQV9JVEVSQVRPUl9TUEVDEAYSEQoNT1BUSU9OQUxfU1BFQxAHEhQK" + "EFBFUl9SRVBMSUNBX1NQRUMQCBIRCg1WQVJJQUJMRV9TUEVDEAkSFgoSUk9X" + "X1BBUlRJVElPTl9TUEVDEAoSGAoUUkVHSVNURVJFRF9UWVBFX1NQRUMQDBIX" + "ChNFWFRFTlNJT05fVFlQRV9TUEVDEA0iBAgLEAtCV1pVZ2l0aHViLmNvbS90" + "ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9nby9jb3JlL3Byb3Rv" + "YnVmL2Zvcl9jb3JlX3Byb3Rvc19nb19wcm90b2IGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				TensorReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[10]
			{
				new GeneratedClrTypeInfo(typeof(StructuredValue), (MessageParser)(object)StructuredValue.Parser, new string[14]
				{
					"NoneValue", "Float64Value", "Int64Value", "StringValue", "BoolValue", "TensorShapeValue", "TensorDtypeValue", "TensorSpecValue", "TypeSpecValue", "BoundedTensorSpecValue",
					"ListValue", "TupleValue", "DictValue", "NamedTupleValue"
				}, new string[1] { "Kind" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(NoneValue), (MessageParser)(object)NoneValue.Parser, (string[])null, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ListValue), (MessageParser)(object)ListValue.Parser, new string[1] { "Values" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(TupleValue), (MessageParser)(object)TupleValue.Parser, new string[1] { "Values" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(DictValue), (MessageParser)(object)DictValue.Parser, new string[1] { "Fields" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(PairValue), (MessageParser)(object)PairValue.Parser, new string[2] { "Key", "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(NamedTupleValue), (MessageParser)(object)NamedTupleValue.Parser, new string[2] { "Name", "Values" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(TensorSpecProto), (MessageParser)(object)TensorSpecProto.Parser, new string[3] { "Name", "Shape", "Dtype" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(BoundedTensorSpecProto), (MessageParser)(object)BoundedTensorSpecProto.Parser, new string[5] { "Name", "Shape", "Dtype", "Minimum", "Maximum" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(TypeSpecProto), (MessageParser)(object)TypeSpecProto.Parser, new string[4] { "TypeSpecClass", "TypeState", "TypeSpecClassName", "NumFlatComponents" }, (string[])null, new Type[1] { typeof(TypeSpecProto.Types.TypeSpecClass) }, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class StructuredValue : IMessage<StructuredValue>, IMessage, IEquatable<StructuredValue>, IDeepCloneable<StructuredValue>
	{
		public enum KindOneofCase
		{
			None = 0,
			NoneValue = 1,
			Float64Value = 11,
			Int64Value = 12,
			StringValue = 13,
			BoolValue = 14,
			TensorShapeValue = 31,
			TensorDtypeValue = 32,
			TensorSpecValue = 33,
			TypeSpecValue = 34,
			BoundedTensorSpecValue = 35,
			ListValue = 51,
			TupleValue = 52,
			DictValue = 53,
			NamedTupleValue = 54
		}

		private static readonly MessageParser<StructuredValue> _parser = new MessageParser<StructuredValue>((Func<StructuredValue>)(() => new StructuredValue()));

		private UnknownFieldSet _unknownFields;

		public const int NoneValueFieldNumber = 1;

		public const int Float64ValueFieldNumber = 11;

		public const int Int64ValueFieldNumber = 12;

		public const int StringValueFieldNumber = 13;

		public const int BoolValueFieldNumber = 14;

		public const int TensorShapeValueFieldNumber = 31;

		public const int TensorDtypeValueFieldNumber = 32;

		public const int TensorSpecValueFieldNumber = 33;

		public const int TypeSpecValueFieldNumber = 34;

		public const int BoundedTensorSpecValueFieldNumber = 35;

		public const int ListValueFieldNumber = 51;

		public const int TupleValueFieldNumber = 52;

		public const int DictValueFieldNumber = 53;

		public const int NamedTupleValueFieldNumber = 54;

		private object kind_;

		private KindOneofCase kindCase_;

		[DebuggerNonUserCode]
		public static MessageParser<StructuredValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public NoneValue NoneValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.NoneValue)
				{
					return null;
				}
				return (NoneValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.NoneValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public double Float64Value
		{
			get
			{
				if (kindCase_ != KindOneofCase.Float64Value)
				{
					return 0.0;
				}
				return (double)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.Float64Value;
			}
		}

		[DebuggerNonUserCode]
		public long Int64Value
		{
			get
			{
				if (kindCase_ != KindOneofCase.Int64Value)
				{
					return 0L;
				}
				return (long)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.Int64Value;
			}
		}

		[DebuggerNonUserCode]
		public string StringValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.StringValue)
				{
					return "";
				}
				return (string)kind_;
			}
			set
			{
				kind_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
				kindCase_ = KindOneofCase.StringValue;
			}
		}

		[DebuggerNonUserCode]
		public bool BoolValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.BoolValue)
				{
					return false;
				}
				return (bool)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.BoolValue;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto TensorShapeValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.TensorShapeValue)
				{
					return null;
				}
				return (TensorShapeProto)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.TensorShapeValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public DataType TensorDtypeValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.TensorDtypeValue)
				{
					return DataType.DtInvalid;
				}
				return (DataType)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = KindOneofCase.TensorDtypeValue;
			}
		}

		[DebuggerNonUserCode]
		public TensorSpecProto TensorSpecValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.TensorSpecValue)
				{
					return null;
				}
				return (TensorSpecProto)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.TensorSpecValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public TypeSpecProto TypeSpecValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.TypeSpecValue)
				{
					return null;
				}
				return (TypeSpecProto)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.TypeSpecValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public BoundedTensorSpecProto BoundedTensorSpecValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.BoundedTensorSpecValue)
				{
					return null;
				}
				return (BoundedTensorSpecProto)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.BoundedTensorSpecValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public ListValue ListValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.ListValue)
				{
					return null;
				}
				return (ListValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.ListValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public TupleValue TupleValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.TupleValue)
				{
					return null;
				}
				return (TupleValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.TupleValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public DictValue DictValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.DictValue)
				{
					return null;
				}
				return (DictValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.DictValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public NamedTupleValue NamedTupleValue
		{
			get
			{
				if (kindCase_ != KindOneofCase.NamedTupleValue)
				{
					return null;
				}
				return (NamedTupleValue)kind_;
			}
			set
			{
				kind_ = value;
				kindCase_ = ((value != null) ? KindOneofCase.NamedTupleValue : KindOneofCase.None);
			}
		}

		[DebuggerNonUserCode]
		public KindOneofCase KindCase => kindCase_;

		[DebuggerNonUserCode]
		public StructuredValue()
		{
		}

		[DebuggerNonUserCode]
		public StructuredValue(StructuredValue other)
			: this()
		{
			switch (other.KindCase)
			{
			case KindOneofCase.NoneValue:
				NoneValue = other.NoneValue.Clone();
				break;
			case KindOneofCase.Float64Value:
				Float64Value = other.Float64Value;
				break;
			case KindOneofCase.Int64Value:
				Int64Value = other.Int64Value;
				break;
			case KindOneofCase.StringValue:
				StringValue = other.StringValue;
				break;
			case KindOneofCase.BoolValue:
				BoolValue = other.BoolValue;
				break;
			case KindOneofCase.TensorShapeValue:
				TensorShapeValue = other.TensorShapeValue.Clone();
				break;
			case KindOneofCase.TensorDtypeValue:
				TensorDtypeValue = other.TensorDtypeValue;
				break;
			case KindOneofCase.TensorSpecValue:
				TensorSpecValue = other.TensorSpecValue.Clone();
				break;
			case KindOneofCase.TypeSpecValue:
				TypeSpecValue = other.TypeSpecValue.Clone();
				break;
			case KindOneofCase.BoundedTensorSpecValue:
				BoundedTensorSpecValue = other.BoundedTensorSpecValue.Clone();
				break;
			case KindOneofCase.ListValue:
				ListValue = other.ListValue.Clone();
				break;
			case KindOneofCase.TupleValue:
				TupleValue = other.TupleValue.Clone();
				break;
			case KindOneofCase.DictValue:
				DictValue = other.DictValue.Clone();
				break;
			case KindOneofCase.NamedTupleValue:
				NamedTupleValue = other.NamedTupleValue.Clone();
				break;
			}
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public StructuredValue Clone()
		{
			return new StructuredValue(this);
		}

		[DebuggerNonUserCode]
		public void ClearKind()
		{
			kindCase_ = KindOneofCase.None;
			kind_ = null;
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as StructuredValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(StructuredValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(NoneValue, other.NoneValue))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Float64Value, other.Float64Value))
			{
				return false;
			}
			if (Int64Value != other.Int64Value)
			{
				return false;
			}
			if (StringValue != other.StringValue)
			{
				return false;
			}
			if (BoolValue != other.BoolValue)
			{
				return false;
			}
			if (!object.Equals(TensorShapeValue, other.TensorShapeValue))
			{
				return false;
			}
			if (TensorDtypeValue != other.TensorDtypeValue)
			{
				return false;
			}
			if (!object.Equals(TensorSpecValue, other.TensorSpecValue))
			{
				return false;
			}
			if (!object.Equals(TypeSpecValue, other.TypeSpecValue))
			{
				return false;
			}
			if (!object.Equals(BoundedTensorSpecValue, other.BoundedTensorSpecValue))
			{
				return false;
			}
			if (!object.Equals(ListValue, other.ListValue))
			{
				return false;
			}
			if (!object.Equals(TupleValue, other.TupleValue))
			{
				return false;
			}
			if (!object.Equals(DictValue, other.DictValue))
			{
				return false;
			}
			if (!object.Equals(NamedTupleValue, other.NamedTupleValue))
			{
				return false;
			}
			if (KindCase != other.KindCase)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (kindCase_ == KindOneofCase.NoneValue)
			{
				num ^= NoneValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.Float64Value)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Float64Value);
			}
			if (kindCase_ == KindOneofCase.Int64Value)
			{
				num ^= Int64Value.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.StringValue)
			{
				num ^= StringValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.BoolValue)
			{
				num ^= BoolValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.TensorShapeValue)
			{
				num ^= TensorShapeValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.TensorDtypeValue)
			{
				num ^= TensorDtypeValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.TensorSpecValue)
			{
				num ^= TensorSpecValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.TypeSpecValue)
			{
				num ^= TypeSpecValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.BoundedTensorSpecValue)
			{
				num ^= BoundedTensorSpecValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.ListValue)
			{
				num ^= ListValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.TupleValue)
			{
				num ^= TupleValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.DictValue)
			{
				num ^= DictValue.GetHashCode();
			}
			if (kindCase_ == KindOneofCase.NamedTupleValue)
			{
				num ^= NamedTupleValue.GetHashCode();
			}
			num ^= (int)kindCase_;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (kindCase_ == KindOneofCase.NoneValue)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)NoneValue);
			}
			if (kindCase_ == KindOneofCase.Float64Value)
			{
				output.WriteRawTag((byte)89);
				output.WriteDouble(Float64Value);
			}
			if (kindCase_ == KindOneofCase.Int64Value)
			{
				output.WriteRawTag((byte)96);
				output.WriteSInt64(Int64Value);
			}
			if (kindCase_ == KindOneofCase.StringValue)
			{
				output.WriteRawTag((byte)106);
				output.WriteString(StringValue);
			}
			if (kindCase_ == KindOneofCase.BoolValue)
			{
				output.WriteRawTag((byte)112);
				output.WriteBool(BoolValue);
			}
			if (kindCase_ == KindOneofCase.TensorShapeValue)
			{
				output.WriteRawTag((byte)250, (byte)1);
				output.WriteMessage((IMessage)(object)TensorShapeValue);
			}
			if (kindCase_ == KindOneofCase.TensorDtypeValue)
			{
				output.WriteRawTag((byte)128, (byte)2);
				output.WriteEnum((int)TensorDtypeValue);
			}
			if (kindCase_ == KindOneofCase.TensorSpecValue)
			{
				output.WriteRawTag((byte)138, (byte)2);
				output.WriteMessage((IMessage)(object)TensorSpecValue);
			}
			if (kindCase_ == KindOneofCase.TypeSpecValue)
			{
				output.WriteRawTag((byte)146, (byte)2);
				output.WriteMessage((IMessage)(object)TypeSpecValue);
			}
			if (kindCase_ == KindOneofCase.BoundedTensorSpecValue)
			{
				output.WriteRawTag((byte)154, (byte)2);
				output.WriteMessage((IMessage)(object)BoundedTensorSpecValue);
			}
			if (kindCase_ == KindOneofCase.ListValue)
			{
				output.WriteRawTag((byte)154, (byte)3);
				output.WriteMessage((IMessage)(object)ListValue);
			}
			if (kindCase_ == KindOneofCase.TupleValue)
			{
				output.WriteRawTag((byte)162, (byte)3);
				output.WriteMessage((IMessage)(object)TupleValue);
			}
			if (kindCase_ == KindOneofCase.DictValue)
			{
				output.WriteRawTag((byte)170, (byte)3);
				output.WriteMessage((IMessage)(object)DictValue);
			}
			if (kindCase_ == KindOneofCase.NamedTupleValue)
			{
				output.WriteRawTag((byte)178, (byte)3);
				output.WriteMessage((IMessage)(object)NamedTupleValue);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (kindCase_ == KindOneofCase.NoneValue)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)NoneValue);
			}
			if (kindCase_ == KindOneofCase.Float64Value)
			{
				num += 9;
			}
			if (kindCase_ == KindOneofCase.Int64Value)
			{
				num += 1 + CodedOutputStream.ComputeSInt64Size(Int64Value);
			}
			if (kindCase_ == KindOneofCase.StringValue)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(StringValue);
			}
			if (kindCase_ == KindOneofCase.BoolValue)
			{
				num += 2;
			}
			if (kindCase_ == KindOneofCase.TensorShapeValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TensorShapeValue);
			}
			if (kindCase_ == KindOneofCase.TensorDtypeValue)
			{
				num += 2 + CodedOutputStream.ComputeEnumSize((int)TensorDtypeValue);
			}
			if (kindCase_ == KindOneofCase.TensorSpecValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TensorSpecValue);
			}
			if (kindCase_ == KindOneofCase.TypeSpecValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TypeSpecValue);
			}
			if (kindCase_ == KindOneofCase.BoundedTensorSpecValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)BoundedTensorSpecValue);
			}
			if (kindCase_ == KindOneofCase.ListValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)ListValue);
			}
			if (kindCase_ == KindOneofCase.TupleValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TupleValue);
			}
			if (kindCase_ == KindOneofCase.DictValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)DictValue);
			}
			if (kindCase_ == KindOneofCase.NamedTupleValue)
			{
				num += 2 + CodedOutputStream.ComputeMessageSize((IMessage)(object)NamedTupleValue);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(StructuredValue other)
		{
			if (other == null)
			{
				return;
			}
			switch (other.KindCase)
			{
			case KindOneofCase.NoneValue:
				if (NoneValue == null)
				{
					NoneValue = new NoneValue();
				}
				NoneValue.MergeFrom(other.NoneValue);
				break;
			case KindOneofCase.Float64Value:
				Float64Value = other.Float64Value;
				break;
			case KindOneofCase.Int64Value:
				Int64Value = other.Int64Value;
				break;
			case KindOneofCase.StringValue:
				StringValue = other.StringValue;
				break;
			case KindOneofCase.BoolValue:
				BoolValue = other.BoolValue;
				break;
			case KindOneofCase.TensorShapeValue:
				if (TensorShapeValue == null)
				{
					TensorShapeValue = new TensorShapeProto();
				}
				TensorShapeValue.MergeFrom(other.TensorShapeValue);
				break;
			case KindOneofCase.TensorDtypeValue:
				TensorDtypeValue = other.TensorDtypeValue;
				break;
			case KindOneofCase.TensorSpecValue:
				if (TensorSpecValue == null)
				{
					TensorSpecValue = new TensorSpecProto();
				}
				TensorSpecValue.MergeFrom(other.TensorSpecValue);
				break;
			case KindOneofCase.TypeSpecValue:
				if (TypeSpecValue == null)
				{
					TypeSpecValue = new TypeSpecProto();
				}
				TypeSpecValue.MergeFrom(other.TypeSpecValue);
				break;
			case KindOneofCase.BoundedTensorSpecValue:
				if (BoundedTensorSpecValue == null)
				{
					BoundedTensorSpecValue = new BoundedTensorSpecProto();
				}
				BoundedTensorSpecValue.MergeFrom(other.BoundedTensorSpecValue);
				break;
			case KindOneofCase.ListValue:
				if (ListValue == null)
				{
					ListValue = new ListValue();
				}
				ListValue.MergeFrom(other.ListValue);
				break;
			case KindOneofCase.TupleValue:
				if (TupleValue == null)
				{
					TupleValue = new TupleValue();
				}
				TupleValue.MergeFrom(other.TupleValue);
				break;
			case KindOneofCase.DictValue:
				if (DictValue == null)
				{
					DictValue = new DictValue();
				}
				DictValue.MergeFrom(other.DictValue);
				break;
			case KindOneofCase.NamedTupleValue:
				if (NamedTupleValue == null)
				{
					NamedTupleValue = new NamedTupleValue();
				}
				NamedTupleValue.MergeFrom(other.NamedTupleValue);
				break;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
				{
					NoneValue noneValue = new NoneValue();
					if (kindCase_ == KindOneofCase.NoneValue)
					{
						noneValue.MergeFrom(NoneValue);
					}
					input.ReadMessage((IMessage)(object)noneValue);
					NoneValue = noneValue;
					break;
				}
				case 89u:
					Float64Value = input.ReadDouble();
					break;
				case 96u:
					Int64Value = input.ReadSInt64();
					break;
				case 106u:
					StringValue = input.ReadString();
					break;
				case 112u:
					BoolValue = input.ReadBool();
					break;
				case 250u:
				{
					TensorShapeProto tensorShapeProto = new TensorShapeProto();
					if (kindCase_ == KindOneofCase.TensorShapeValue)
					{
						tensorShapeProto.MergeFrom(TensorShapeValue);
					}
					input.ReadMessage((IMessage)(object)tensorShapeProto);
					TensorShapeValue = tensorShapeProto;
					break;
				}
				case 256u:
					kind_ = input.ReadEnum();
					kindCase_ = KindOneofCase.TensorDtypeValue;
					break;
				case 266u:
				{
					TensorSpecProto tensorSpecProto = new TensorSpecProto();
					if (kindCase_ == KindOneofCase.TensorSpecValue)
					{
						tensorSpecProto.MergeFrom(TensorSpecValue);
					}
					input.ReadMessage((IMessage)(object)tensorSpecProto);
					TensorSpecValue = tensorSpecProto;
					break;
				}
				case 274u:
				{
					TypeSpecProto typeSpecProto = new TypeSpecProto();
					if (kindCase_ == KindOneofCase.TypeSpecValue)
					{
						typeSpecProto.MergeFrom(TypeSpecValue);
					}
					input.ReadMessage((IMessage)(object)typeSpecProto);
					TypeSpecValue = typeSpecProto;
					break;
				}
				case 282u:
				{
					BoundedTensorSpecProto boundedTensorSpecProto = new BoundedTensorSpecProto();
					if (kindCase_ == KindOneofCase.BoundedTensorSpecValue)
					{
						boundedTensorSpecProto.MergeFrom(BoundedTensorSpecValue);
					}
					input.ReadMessage((IMessage)(object)boundedTensorSpecProto);
					BoundedTensorSpecValue = boundedTensorSpecProto;
					break;
				}
				case 410u:
				{
					ListValue listValue = new ListValue();
					if (kindCase_ == KindOneofCase.ListValue)
					{
						listValue.MergeFrom(ListValue);
					}
					input.ReadMessage((IMessage)(object)listValue);
					ListValue = listValue;
					break;
				}
				case 418u:
				{
					TupleValue tupleValue = new TupleValue();
					if (kindCase_ == KindOneofCase.TupleValue)
					{
						tupleValue.MergeFrom(TupleValue);
					}
					input.ReadMessage((IMessage)(object)tupleValue);
					TupleValue = tupleValue;
					break;
				}
				case 426u:
				{
					DictValue dictValue = new DictValue();
					if (kindCase_ == KindOneofCase.DictValue)
					{
						dictValue.MergeFrom(DictValue);
					}
					input.ReadMessage((IMessage)(object)dictValue);
					DictValue = dictValue;
					break;
				}
				case 434u:
				{
					NamedTupleValue namedTupleValue = new NamedTupleValue();
					if (kindCase_ == KindOneofCase.NamedTupleValue)
					{
						namedTupleValue.MergeFrom(NamedTupleValue);
					}
					input.ReadMessage((IMessage)(object)namedTupleValue);
					NamedTupleValue = namedTupleValue;
					break;
				}
				}
			}
		}
	}
	public sealed class NoneValue : IMessage<NoneValue>, IMessage, IEquatable<NoneValue>, IDeepCloneable<NoneValue>
	{
		private static readonly MessageParser<NoneValue> _parser = new MessageParser<NoneValue>((Func<NoneValue>)(() => new NoneValue()));

		private UnknownFieldSet _unknownFields;

		[DebuggerNonUserCode]
		public static MessageParser<NoneValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public NoneValue()
		{
		}

		[DebuggerNonUserCode]
		public NoneValue(NoneValue other)
			: this()
		{
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public NoneValue Clone()
		{
			return new NoneValue(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as NoneValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(NoneValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(NoneValue other)
		{
			if (other != null)
			{
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			while (input.ReadTag() != 0)
			{
				_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
			}
		}
	}
	public sealed class ListValue : IMessage<ListValue>, IMessage, IEquatable<ListValue>, IDeepCloneable<ListValue>
	{
		private static readonly MessageParser<ListValue> _parser = new MessageParser<ListValue>((Func<ListValue>)(() => new ListValue()));

		private UnknownFieldSet _unknownFields;

		public const int ValuesFieldNumber = 1;

		private static readonly FieldCodec<StructuredValue> _repeated_values_codec = FieldCodec.ForMessage<StructuredValue>(10u, StructuredValue.Parser);

		private readonly RepeatedField<StructuredValue> values_ = new RepeatedField<StructuredValue>();

		[DebuggerNonUserCode]
		public static MessageParser<ListValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<StructuredValue> Values => values_;

		[DebuggerNonUserCode]
		public ListValue()
		{
		}

		[DebuggerNonUserCode]
		public ListValue(ListValue other)
			: this()
		{
			values_ = other.values_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ListValue Clone()
		{
			return new ListValue(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ListValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(ListValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!values_.Equals(other.values_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)values_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			values_.WriteTo(output, _repeated_values_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += values_.CalculateSize(_repeated_values_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ListValue other)
		{
			if (other != null)
			{
				values_.Add((IEnumerable<StructuredValue>)other.values_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					values_.AddEntriesFrom(input, _repeated_values_codec);
				}
			}
		}
	}
	public sealed class TupleValue : IMessage<TupleValue>, IMessage, IEquatable<TupleValue>, IDeepCloneable<TupleValue>
	{
		private static readonly MessageParser<TupleValue> _parser = new MessageParser<TupleValue>((Func<TupleValue>)(() => new TupleValue()));

		private UnknownFieldSet _unknownFields;

		public const int ValuesFieldNumber = 1;

		private static readonly FieldCodec<StructuredValue> _repeated_values_codec = FieldCodec.ForMessage<StructuredValue>(10u, StructuredValue.Parser);

		private readonly RepeatedField<StructuredValue> values_ = new RepeatedField<StructuredValue>();

		[DebuggerNonUserCode]
		public static MessageParser<TupleValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<StructuredValue> Values => values_;

		[DebuggerNonUserCode]
		public TupleValue()
		{
		}

		[DebuggerNonUserCode]
		public TupleValue(TupleValue other)
			: this()
		{
			values_ = other.values_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TupleValue Clone()
		{
			return new TupleValue(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TupleValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(TupleValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!values_.Equals(other.values_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)values_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			values_.WriteTo(output, _repeated_values_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += values_.CalculateSize(_repeated_values_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TupleValue other)
		{
			if (other != null)
			{
				values_.Add((IEnumerable<StructuredValue>)other.values_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					values_.AddEntriesFrom(input, _repeated_values_codec);
				}
			}
		}
	}
	public sealed class DictValue : IMessage<DictValue>, IMessage, IEquatable<DictValue>, IDeepCloneable<DictValue>
	{
		private static readonly MessageParser<DictValue> _parser = new MessageParser<DictValue>((Func<DictValue>)(() => new DictValue()));

		private UnknownFieldSet _unknownFields;

		public const int FieldsFieldNumber = 1;

		private static readonly Codec<string, StructuredValue> _map_fields_codec = new Codec<string, StructuredValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<StructuredValue>(18u, StructuredValue.Parser), 10u);

		private readonly MapField<string, StructuredValue> fields_ = new MapField<string, StructuredValue>();

		[DebuggerNonUserCode]
		public static MessageParser<DictValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public MapField<string, StructuredValue> Fields => fields_;

		[DebuggerNonUserCode]
		public DictValue()
		{
		}

		[DebuggerNonUserCode]
		public DictValue(DictValue other)
			: this()
		{
			fields_ = other.fields_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public DictValue Clone()
		{
			return new DictValue(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as DictValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(DictValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!Fields.Equals(other.Fields))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)Fields).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			fields_.WriteTo(output, _map_fields_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += fields_.CalculateSize(_map_fields_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(DictValue other)
		{
			if (other != null)
			{
				fields_.Add((IDictionary<string, StructuredValue>)other.fields_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					fields_.AddEntriesFrom(input, _map_fields_codec);
				}
			}
		}
	}
	public sealed class PairValue : IMessage<PairValue>, IMessage, IEquatable<PairValue>, IDeepCloneable<PairValue>
	{
		private static readonly MessageParser<PairValue> _parser = new MessageParser<PairValue>((Func<PairValue>)(() => new PairValue()));

		private UnknownFieldSet _unknownFields;

		public const int KeyFieldNumber = 1;

		private string key_ = "";

		public const int ValueFieldNumber = 2;

		private StructuredValue value_;

		[DebuggerNonUserCode]
		public static MessageParser<PairValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Key
		{
			get
			{
				return key_;
			}
			set
			{
				key_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public StructuredValue Value
		{
			get
			{
				return value_;
			}
			set
			{
				value_ = value;
			}
		}

		[DebuggerNonUserCode]
		public PairValue()
		{
		}

		[DebuggerNonUserCode]
		public PairValue(PairValue other)
			: this()
		{
			key_ = other.key_;
			value_ = ((other.value_ != null) ? other.value_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public PairValue Clone()
		{
			return new PairValue(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as PairValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(PairValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Key != other.Key)
			{
				return false;
			}
			if (!object.Equals(Value, other.Value))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Key.Length != 0)
			{
				num ^= Key.GetHashCode();
			}
			if (value_ != null)
			{
				num ^= Value.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Key.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Key);
			}
			if (value_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Value);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Key.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Key);
			}
			if (value_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Value);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(PairValue other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Key.Length != 0)
			{
				Key = other.Key;
			}
			if (other.value_ != null)
			{
				if (value_ == null)
				{
					Value = new StructuredValue();
				}
				Value.MergeFrom(other.Value);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Key = input.ReadString();
					break;
				case 18u:
					if (value_ == null)
					{
						Value = new StructuredValue();
					}
					input.ReadMessage((IMessage)(object)Value);
					break;
				}
			}
		}
	}
	public sealed class NamedTupleValue : IMessage<NamedTupleValue>, IMessage, IEquatable<NamedTupleValue>, IDeepCloneable<NamedTupleValue>
	{
		private static readonly MessageParser<NamedTupleValue> _parser = new MessageParser<NamedTupleValue>((Func<NamedTupleValue>)(() => new NamedTupleValue()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int ValuesFieldNumber = 2;

		private static readonly FieldCodec<PairValue> _repeated_values_codec = FieldCodec.ForMessage<PairValue>(18u, PairValue.Parser);

		private readonly RepeatedField<PairValue> values_ = new RepeatedField<PairValue>();

		[DebuggerNonUserCode]
		public static MessageParser<NamedTupleValue> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<PairValue> Values => values_;

		[DebuggerNonUserCode]
		public NamedTupleValue()
		{
		}

		[DebuggerNonUserCode]
		public NamedTupleValue(NamedTupleValue other)
			: this()
		{
			name_ = other.name_;
			values_ = other.values_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public NamedTupleValue Clone()
		{
			return new NamedTupleValue(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as NamedTupleValue);
		}

		[DebuggerNonUserCode]
		public bool Equals(NamedTupleValue other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!values_.Equals(other.values_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			num ^= ((object)values_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			values_.WriteTo(output, _repeated_values_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			num += values_.CalculateSize(_repeated_values_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(NamedTupleValue other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				values_.Add((IEnumerable<PairValue>)other.values_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					values_.AddEntriesFrom(input, _repeated_values_codec);
					break;
				}
			}
		}
	}
	public sealed class TensorSpecProto : IMessage<TensorSpecProto>, IMessage, IEquatable<TensorSpecProto>, IDeepCloneable<TensorSpecProto>
	{
		private static readonly MessageParser<TensorSpecProto> _parser = new MessageParser<TensorSpecProto>((Func<TensorSpecProto>)(() => new TensorSpecProto()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int ShapeFieldNumber = 2;

		private TensorShapeProto shape_;

		public const int DtypeFieldNumber = 3;

		private DataType dtype_;

		[DebuggerNonUserCode]
		public static MessageParser<TensorSpecProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto Shape
		{
			get
			{
				return shape_;
			}
			set
			{
				shape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public DataType Dtype
		{
			get
			{
				return dtype_;
			}
			set
			{
				dtype_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorSpecProto()
		{
		}

		[DebuggerNonUserCode]
		public TensorSpecProto(TensorSpecProto other)
			: this()
		{
			name_ = other.name_;
			shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
			dtype_ = other.dtype_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TensorSpecProto Clone()
		{
			return new TensorSpecProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TensorSpecProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(TensorSpecProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!object.Equals(Shape, other.Shape))
			{
				return false;
			}
			if (Dtype != other.Dtype)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (shape_ != null)
			{
				num ^= Shape.GetHashCode();
			}
			if (Dtype != DataType.DtInvalid)
			{
				num ^= Dtype.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (shape_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Shape);
			}
			if (Dtype != DataType.DtInvalid)
			{
				output.WriteRawTag((byte)24);
				output.WriteEnum((int)Dtype);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (shape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
			}
			if (Dtype != DataType.DtInvalid)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TensorSpecProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.shape_ != null)
			{
				if (shape_ == null)
				{
					Shape = new TensorShapeProto();
				}
				Shape.MergeFrom(other.Shape);
			}
			if (other.Dtype != DataType.DtInvalid)
			{
				Dtype = other.Dtype;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					if (shape_ == null)
					{
						Shape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)Shape);
					break;
				case 24u:
					Dtype = (DataType)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class BoundedTensorSpecProto : IMessage<BoundedTensorSpecProto>, IMessage, IEquatable<BoundedTensorSpecProto>, IDeepCloneable<BoundedTensorSpecProto>
	{
		private static readonly MessageParser<BoundedTensorSpecProto> _parser = new MessageParser<BoundedTensorSpecProto>((Func<BoundedTensorSpecProto>)(() => new BoundedTensorSpecProto()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int ShapeFieldNumber = 2;

		private TensorShapeProto shape_;

		public const int DtypeFieldNumber = 3;

		private DataType dtype_;

		public const int MinimumFieldNumber = 4;

		private TensorProto minimum_;

		public const int MaximumFieldNumber = 5;

		private TensorProto maximum_;

		[DebuggerNonUserCode]
		public static MessageParser<BoundedTensorSpecProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto Shape
		{
			get
			{
				return shape_;
			}
			set
			{
				shape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public DataType Dtype
		{
			get
			{
				return dtype_;
			}
			set
			{
				dtype_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorProto Minimum
		{
			get
			{
				return minimum_;
			}
			set
			{
				minimum_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorProto Maximum
		{
			get
			{
				return maximum_;
			}
			set
			{
				maximum_ = value;
			}
		}

		[DebuggerNonUserCode]
		public BoundedTensorSpecProto()
		{
		}

		[DebuggerNonUserCode]
		public BoundedTensorSpecProto(BoundedTensorSpecProto other)
			: this()
		{
			name_ = other.name_;
			shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
			dtype_ = other.dtype_;
			minimum_ = ((other.minimum_ != null) ? other.minimum_.Clone() : null);
			maximum_ = ((other.maximum_ != null) ? other.maximum_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public BoundedTensorSpecProto Clone()
		{
			return new BoundedTensorSpecProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as BoundedTensorSpecProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(BoundedTensorSpecProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (!object.Equals(Shape, other.Shape))
			{
				return false;
			}
			if (Dtype != other.Dtype)
			{
				return false;
			}
			if (!object.Equals(Minimum, other.Minimum))
			{
				return false;
			}
			if (!object.Equals(Maximum, other.Maximum))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (shape_ != null)
			{
				num ^= Shape.GetHashCode();
			}
			if (Dtype != DataType.DtInvalid)
			{
				num ^= Dtype.GetHashCode();
			}
			if (minimum_ != null)
			{
				num ^= Minimum.GetHashCode();
			}
			if (maximum_ != null)
			{
				num ^= Maximum.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (shape_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Shape);
			}
			if (Dtype != DataType.DtInvalid)
			{
				output.WriteRawTag((byte)24);
				output.WriteEnum((int)Dtype);
			}
			if (minimum_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)Minimum);
			}
			if (maximum_ != null)
			{
				output.WriteRawTag((byte)42);
				output.WriteMessage((IMessage)(object)Maximum);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (shape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
			}
			if (Dtype != DataType.DtInvalid)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
			}
			if (minimum_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Minimum);
			}
			if (maximum_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Maximum);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(BoundedTensorSpecProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.shape_ != null)
			{
				if (shape_ == null)
				{
					Shape = new TensorShapeProto();
				}
				Shape.MergeFrom(other.Shape);
			}
			if (other.Dtype != DataType.DtInvalid)
			{
				Dtype = other.Dtype;
			}
			if (other.minimum_ != null)
			{
				if (minimum_ == null)
				{
					Minimum = new TensorProto();
				}
				Minimum.MergeFrom(other.Minimum);
			}
			if (other.maximum_ != null)
			{
				if (maximum_ == null)
				{
					Maximum = new TensorProto();
				}
				Maximum.MergeFrom(other.Maximum);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					if (shape_ == null)
					{
						Shape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)Shape);
					break;
				case 24u:
					Dtype = (DataType)input.ReadEnum();
					break;
				case 34u:
					if (minimum_ == null)
					{
						Minimum = new TensorProto();
					}
					input.ReadMessage((IMessage)(object)Minimum);
					break;
				case 42u:
					if (maximum_ == null)
					{
						Maximum = new TensorProto();
					}
					input.ReadMessage((IMessage)(object)Maximum);
					break;
				}
			}
		}
	}
	public sealed class TypeSpecProto : IMessage<TypeSpecProto>, IMessage, IEquatable<TypeSpecProto>, IDeepCloneable<TypeSpecProto>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum TypeSpecClass
			{
				[OriginalName("UNKNOWN")]
				Unknown = 0,
				[OriginalName("SPARSE_TENSOR_SPEC")]
				SparseTensorSpec = 1,
				[OriginalName("INDEXED_SLICES_SPEC")]
				IndexedSlicesSpec = 2,
				[OriginalName("RAGGED_TENSOR_SPEC")]
				RaggedTensorSpec = 3,
				[OriginalName("TENSOR_ARRAY_SPEC")]
				TensorArraySpec = 4,
				[OriginalName("DATA_DATASET_SPEC")]
				DataDatasetSpec = 5,
				[OriginalName("DATA_ITERATOR_SPEC")]
				DataIteratorSpec = 6,
				[OriginalName("OPTIONAL_SPEC")]
				OptionalSpec = 7,
				[OriginalName("PER_REPLICA_SPEC")]
				PerReplicaSpec = 8,
				[OriginalName("VARIABLE_SPEC")]
				VariableSpec = 9,
				[OriginalName("ROW_PARTITION_SPEC")]
				RowPartitionSpec = 10,
				[OriginalName("REGISTERED_TYPE_SPEC")]
				RegisteredTypeSpec = 12,
				[OriginalName("EXTENSION_TYPE_SPEC")]
				ExtensionTypeSpec = 13
			}
		}

		private static readonly MessageParser<TypeSpecProto> _parser = new MessageParser<TypeSpecProto>((Func<TypeSpecProto>)(() => new TypeSpecProto()));

		private UnknownFieldSet _unknownFields;

		public const int TypeSpecClassFieldNumber = 1;

		private Types.TypeSpecClass typeSpecClass_;

		public const int TypeStateFieldNumber = 2;

		private StructuredValue typeState_;

		public const int TypeSpecClassNameFieldNumber = 3;

		private string typeSpecClassName_ = "";

		public const int NumFlatComponentsFieldNumber = 4;

		private int numFlatComponents_;

		[DebuggerNonUserCode]
		public static MessageParser<TypeSpecProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => StructReflection.Descriptor.MessageTypes[9];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.TypeSpecClass TypeSpecClass
		{
			get
			{
				return typeSpecClass_;
			}
			set
			{
				typeSpecClass_ = value;
			}
		}

		[DebuggerNonUserCode]
		public StructuredValue TypeState
		{
			get
			{
				return typeState_;
			}
			set
			{
				typeState_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string TypeSpecClassName
		{
			get
			{
				return typeSpecClassName_;
			}
			set
			{
				typeSpecClassName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public int NumFlatComponents
		{
			get
			{
				return numFlatComponents_;
			}
			set
			{
				numFlatComponents_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TypeSpecProto()
		{
		}

		[DebuggerNonUserCode]
		public TypeSpecProto(TypeSpecProto other)
			: this()
		{
			typeSpecClass_ = other.typeSpecClass_;
			typeState_ = ((other.typeState_ != null) ? other.typeState_.Clone() : null);
			typeSpecClassName_ = other.typeSpecClassName_;
			numFlatComponents_ = other.numFlatComponents_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TypeSpecProto Clone()
		{
			return new TypeSpecProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TypeSpecProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(TypeSpecProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TypeSpecClass != other.TypeSpecClass)
			{
				return false;
			}
			if (!object.Equals(TypeState, other.TypeState))
			{
				return false;
			}
			if (TypeSpecClassName != other.TypeSpecClassName)
			{
				return false;
			}
			if (NumFlatComponents != other.NumFlatComponents)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TypeSpecClass != Types.TypeSpecClass.Unknown)
			{
				num ^= TypeSpecClass.GetHashCode();
			}
			if (typeState_ != null)
			{
				num ^= TypeState.GetHashCode();
			}
			if (TypeSpecClassName.Length != 0)
			{
				num ^= TypeSpecClassName.GetHashCode();
			}
			if (NumFlatComponents != 0)
			{
				num ^= NumFlatComponents.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TypeSpecClass != Types.TypeSpecClass.Unknown)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)TypeSpecClass);
			}
			if (typeState_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)TypeState);
			}
			if (TypeSpecClassName.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(TypeSpecClassName);
			}
			if (NumFlatComponents != 0)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt32(NumFlatComponents);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TypeSpecClass != Types.TypeSpecClass.Unknown)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)TypeSpecClass);
			}
			if (typeState_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TypeState);
			}
			if (TypeSpecClassName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TypeSpecClassName);
			}
			if (NumFlatComponents != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(NumFlatComponents);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TypeSpecProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.TypeSpecClass != Types.TypeSpecClass.Unknown)
			{
				TypeSpecClass = other.TypeSpecClass;
			}
			if (other.typeState_ != null)
			{
				if (typeState_ == null)
				{
					TypeState = new StructuredValue();
				}
				TypeState.MergeFrom(other.TypeState);
			}
			if (other.TypeSpecClassName.Length != 0)
			{
				TypeSpecClassName = other.TypeSpecClassName;
			}
			if (other.NumFlatComponents != 0)
			{
				NumFlatComponents = other.NumFlatComponents;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					TypeSpecClass = (Types.TypeSpecClass)input.ReadEnum();
					break;
				case 18u:
					if (typeState_ == null)
					{
						TypeState = new StructuredValue();
					}
					input.ReadMessage((IMessage)(object)TypeState);
					break;
				case 26u:
					TypeSpecClassName = input.ReadString();
					break;
				case 32u:
					NumFlatComponents = input.ReadInt32();
					break;
				}
			}
		}
	}
	public static class SummaryReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static SummaryReflection()
		{
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Expected O, but got Unknown
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Expected O, but got Unknown
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Expected O, but got Unknown
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0240: Expected O, but got Unknown
			//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Expected O, but got Unknown
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Expected O, but got Unknown
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Expected O, but got Unknown
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_036f: Expected O, but got Unknown
			//IL_036f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiZ0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc3VtbWFyeS5wcm90bxILdGVu" + "c29yYm9hcmQaJXRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by90ZW5zb3IucHJv" + "dG8iJwoSU3VtbWFyeURlc2NyaXB0aW9uEhEKCXR5cGVfaGludBgBIAEoCSKH" + "AQoOSGlzdG9ncmFtUHJvdG8SCwoDbWluGAEgASgBEgsKA21heBgCIAEoARIL" + "CgNudW0YAyABKAESCwoDc3VtGAQgASgBEhMKC3N1bV9zcXVhcmVzGAUgASgB" + "EhgKDGJ1Y2tldF9saW1pdBgGIAMoAUICEAESEgoGYnVja2V0GAcgAygBQgIQ" + "ASLiAQoPU3VtbWFyeU1ldGFkYXRhEjwKC3BsdWdpbl9kYXRhGAEgASgLMicu" + "dGVuc29yYm9hcmQuU3VtbWFyeU1ldGFkYXRhLlBsdWdpbkRhdGESFAoMZGlz" + "cGxheV9uYW1lGAIgASgJEhsKE3N1bW1hcnlfZGVzY3JpcHRpb24YAyABKAkS" + "KgoKZGF0YV9jbGFzcxgEIAEoDjIWLnRlbnNvcmJvYXJkLkRhdGFDbGFzcxoy" + "CgpQbHVnaW5EYXRhEhMKC3BsdWdpbl9uYW1lGAEgASgJEg8KB2NvbnRlbnQY" + "AiABKAwi5AQKB1N1bW1hcnkSKQoFdmFsdWUYASADKAsyGi50ZW5zb3Jib2Fy" + "ZC5TdW1tYXJ5LlZhbHVlGlgKBUltYWdlEg4KBmhlaWdodBgBIAEoBRINCgV3" + "aWR0aBgCIAEoBRISCgpjb2xvcnNwYWNlGAMgASgFEhwKFGVuY29kZWRfaW1h" + "Z2Vfc3RyaW5nGAQgASgMGn0KBUF1ZGlvEhMKC3NhbXBsZV9yYXRlGAEgASgC" + "EhQKDG51bV9jaGFubmVscxgCIAEoAxIVCg1sZW5ndGhfZnJhbWVzGAMgASgD" + "EhwKFGVuY29kZWRfYXVkaW9fc3RyaW5nGAQgASgMEhQKDGNvbnRlbnRfdHlw" + "ZRgFIAEoCRrUAgoFVmFsdWUSEQoJbm9kZV9uYW1lGAcgASgJEgsKA3RhZxgB" + "IAEoCRIuCghtZXRhZGF0YRgJIAEoCzIcLnRlbnNvcmJvYXJkLlN1bW1hcnlN" + "ZXRhZGF0YRIWCgxzaW1wbGVfdmFsdWUYAiABKAJIABImChxvYnNvbGV0ZV9v" + "bGRfc3R5bGVfaGlzdG9ncmFtGAMgASgMSAASKwoFaW1hZ2UYBCABKAsyGi50" + "ZW5zb3Jib2FyZC5TdW1tYXJ5LkltYWdlSAASLAoFaGlzdG8YBSABKAsyGy50" + "ZW5zb3Jib2FyZC5IaXN0b2dyYW1Qcm90b0gAEisKBWF1ZGlvGAYgASgLMhou" + "dGVuc29yYm9hcmQuU3VtbWFyeS5BdWRpb0gAEioKBnRlbnNvchgIIAEoCzIY" + "LnRlbnNvcmJvYXJkLlRlbnNvclByb3RvSABCBwoFdmFsdWUqbwoJRGF0YUNs" + "YXNzEhYKEkRBVEFfQ0xBU1NfVU5LTk9XThAAEhUKEURBVEFfQ0xBU1NfU0NB" + "TEFSEAESFQoRREFUQV9DTEFTU19URU5TT1IQAhIcChhEQVRBX0NMQVNTX0JM" + "T0JfU0VRVUVOQ0UQA0J+ChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDVN1" + "bW1hcnlQcm90b3NQAVpOZ2l0aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZs" + "b3cvdGVuc29yZmxvdy9nby9jb3JlL2ZyYW1ld29yay9zdW1tYXJ5X2dvX3By" + "b3Rv+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[1] { TensorReflection.Descriptor }, new GeneratedClrTypeInfo(new Type[1] { typeof(DataClass) }, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[4]
			{
				new GeneratedClrTypeInfo(typeof(SummaryDescription), (MessageParser)(object)SummaryDescription.Parser, new string[1] { "TypeHint" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(HistogramProto), (MessageParser)(object)HistogramProto.Parser, new string[7] { "Min", "Max", "Num", "Sum", "SumSquares", "BucketLimit", "Bucket" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SummaryMetadata), (MessageParser)(object)SummaryMetadata.Parser, new string[4] { "PluginData", "DisplayName", "SummaryDescription", "DataClass" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(SummaryMetadata.Types.PluginData), (MessageParser)(object)SummaryMetadata.Types.PluginData.Parser, new string[2] { "PluginName", "Content" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(Summary), (MessageParser)(object)Summary.Parser, new string[1] { "Value" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[3]
				{
					new GeneratedClrTypeInfo(typeof(Summary.Types.Image), (MessageParser)(object)Summary.Types.Image.Parser, new string[4] { "Height", "Width", "Colorspace", "EncodedImageString" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(Summary.Types.Audio), (MessageParser)(object)Summary.Types.Audio.Parser, new string[5] { "SampleRate", "NumChannels", "LengthFrames", "EncodedAudioString", "ContentType" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
					new GeneratedClrTypeInfo(typeof(Summary.Types.Value), (MessageParser)(object)Summary.Types.Value.Parser, new string[9] { "NodeName", "Tag", "Metadata", "SimpleValue", "ObsoleteOldStyleHistogram", "Image", "Histo", "Audio", "Tensor" }, new string[1] { "Value" }, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				})
			}));
		}
	}
	public enum DataClass
	{
		[OriginalName("DATA_CLASS_UNKNOWN")]
		Unknown,
		[OriginalName("DATA_CLASS_SCALAR")]
		Scalar,
		[OriginalName("DATA_CLASS_TENSOR")]
		Tensor,
		[OriginalName("DATA_CLASS_BLOB_SEQUENCE")]
		BlobSequence
	}
	public sealed class SummaryDescription : IMessage<SummaryDescription>, IMessage, IEquatable<SummaryDescription>, IDeepCloneable<SummaryDescription>
	{
		private static readonly MessageParser<SummaryDescription> _parser = new MessageParser<SummaryDescription>((Func<SummaryDescription>)(() => new SummaryDescription()));

		private UnknownFieldSet _unknownFields;

		public const int TypeHintFieldNumber = 1;

		private string typeHint_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<SummaryDescription> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SummaryReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string TypeHint
		{
			get
			{
				return typeHint_;
			}
			set
			{
				typeHint_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SummaryDescription()
		{
		}

		[DebuggerNonUserCode]
		public SummaryDescription(SummaryDescription other)
			: this()
		{
			typeHint_ = other.typeHint_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SummaryDescription Clone()
		{
			return new SummaryDescription(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SummaryDescription);
		}

		[DebuggerNonUserCode]
		public bool Equals(SummaryDescription other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TypeHint != other.TypeHint)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TypeHint.Length != 0)
			{
				num ^= TypeHint.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TypeHint.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(TypeHint);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TypeHint.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TypeHint);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SummaryDescription other)
		{
			if (other != null)
			{
				if (other.TypeHint.Length != 0)
				{
					TypeHint = other.TypeHint;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					TypeHint = input.ReadString();
				}
			}
		}
	}
	public sealed class HistogramProto : IMessage<HistogramProto>, IMessage, IEquatable<HistogramProto>, IDeepCloneable<HistogramProto>
	{
		private static readonly MessageParser<HistogramProto> _parser = new MessageParser<HistogramProto>((Func<HistogramProto>)(() => new HistogramProto()));

		private UnknownFieldSet _unknownFields;

		public const int MinFieldNumber = 1;

		private double min_;

		public const int MaxFieldNumber = 2;

		private double max_;

		public const int NumFieldNumber = 3;

		private double num_;

		public const int SumFieldNumber = 4;

		private double sum_;

		public const int SumSquaresFieldNumber = 5;

		private double sumSquares_;

		public const int BucketLimitFieldNumber = 6;

		private static readonly FieldCodec<double> _repeated_bucketLimit_codec = FieldCodec.ForDouble(50u);

		private readonly RepeatedField<double> bucketLimit_ = new RepeatedField<double>();

		public const int BucketFieldNumber = 7;

		private static readonly FieldCodec<double> _repeated_bucket_codec = FieldCodec.ForDouble(58u);

		private readonly RepeatedField<double> bucket_ = new RepeatedField<double>();

		[DebuggerNonUserCode]
		public static MessageParser<HistogramProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SummaryReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public double Min
		{
			get
			{
				return min_;
			}
			set
			{
				min_ = value;
			}
		}

		[DebuggerNonUserCode]
		public double Max
		{
			get
			{
				return max_;
			}
			set
			{
				max_ = value;
			}
		}

		[DebuggerNonUserCode]
		public double Num
		{
			get
			{
				return num_;
			}
			set
			{
				num_ = value;
			}
		}

		[DebuggerNonUserCode]
		public double Sum
		{
			get
			{
				return sum_;
			}
			set
			{
				sum_ = value;
			}
		}

		[DebuggerNonUserCode]
		public double SumSquares
		{
			get
			{
				return sumSquares_;
			}
			set
			{
				sumSquares_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<double> BucketLimit => bucketLimit_;

		[DebuggerNonUserCode]
		public RepeatedField<double> Bucket => bucket_;

		[DebuggerNonUserCode]
		public HistogramProto()
		{
		}

		[DebuggerNonUserCode]
		public HistogramProto(HistogramProto other)
			: this()
		{
			min_ = other.min_;
			max_ = other.max_;
			num_ = other.num_;
			sum_ = other.sum_;
			sumSquares_ = other.sumSquares_;
			bucketLimit_ = other.bucketLimit_.Clone();
			bucket_ = other.bucket_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public HistogramProto Clone()
		{
			return new HistogramProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as HistogramProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(HistogramProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Min, other.Min))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Max, other.Max))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Num, other.Num))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(Sum, other.Sum))
			{
				return false;
			}
			if (!ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.Equals(SumSquares, other.SumSquares))
			{
				return false;
			}
			if (!bucketLimit_.Equals(other.bucketLimit_))
			{
				return false;
			}
			if (!bucket_.Equals(other.bucket_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Min != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Min);
			}
			if (Max != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Max);
			}
			if (Num != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Num);
			}
			if (Sum != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(Sum);
			}
			if (SumSquares != 0.0)
			{
				num ^= ProtobufEqualityComparers.BitwiseDoubleEqualityComparer.GetHashCode(SumSquares);
			}
			num ^= ((object)bucketLimit_).GetHashCode();
			num ^= ((object)bucket_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Min != 0.0)
			{
				output.WriteRawTag((byte)9);
				output.WriteDouble(Min);
			}
			if (Max != 0.0)
			{
				output.WriteRawTag((byte)17);
				output.WriteDouble(Max);
			}
			if (Num != 0.0)
			{
				output.WriteRawTag((byte)25);
				output.WriteDouble(Num);
			}
			if (Sum != 0.0)
			{
				output.WriteRawTag((byte)33);
				output.WriteDouble(Sum);
			}
			if (SumSquares != 0.0)
			{
				output.WriteRawTag((byte)41);
				output.WriteDouble(SumSquares);
			}
			bucketLimit_.WriteTo(output, _repeated_bucketLimit_codec);
			bucket_.WriteTo(output, _repeated_bucket_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Min != 0.0)
			{
				num += 9;
			}
			if (Max != 0.0)
			{
				num += 9;
			}
			if (Num != 0.0)
			{
				num += 9;
			}
			if (Sum != 0.0)
			{
				num += 9;
			}
			if (SumSquares != 0.0)
			{
				num += 9;
			}
			num += bucketLimit_.CalculateSize(_repeated_bucketLimit_codec);
			num += bucket_.CalculateSize(_repeated_bucket_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(HistogramProto other)
		{
			if (other != null)
			{
				if (other.Min != 0.0)
				{
					Min = other.Min;
				}
				if (other.Max != 0.0)
				{
					Max = other.Max;
				}
				if (other.Num != 0.0)
				{
					Num = other.Num;
				}
				if (other.Sum != 0.0)
				{
					Sum = other.Sum;
				}
				if (other.SumSquares != 0.0)
				{
					SumSquares = other.SumSquares;
				}
				bucketLimit_.Add((IEnumerable<double>)other.bucketLimit_);
				bucket_.Add((IEnumerable<double>)other.bucket_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 9u:
					Min = input.ReadDouble();
					break;
				case 17u:
					Max = input.ReadDouble();
					break;
				case 25u:
					Num = input.ReadDouble();
					break;
				case 33u:
					Sum = input.ReadDouble();
					break;
				case 41u:
					SumSquares = input.ReadDouble();
					break;
				case 49u:
				case 50u:
					bucketLimit_.AddEntriesFrom(input, _repeated_bucketLimit_codec);
					break;
				case 57u:
				case 58u:
					bucket_.AddEntriesFrom(input, _repeated_bucket_codec);
					break;
				}
			}
		}
	}
	public sealed class SummaryMetadata : IMessage<SummaryMetadata>, IMessage, IEquatable<SummaryMetadata>, IDeepCloneable<SummaryMetadata>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class PluginData : IMessage<PluginData>, IMessage, IEquatable<PluginData>, IDeepCloneable<PluginData>
			{
				private static readonly MessageParser<PluginData> _parser = new MessageParser<PluginData>((Func<PluginData>)(() => new PluginData()));

				private UnknownFieldSet _unknownFields;

				public const int PluginNameFieldNumber = 1;

				private string pluginName_ = "";

				public const int ContentFieldNumber = 2;

				private ByteString content_ = ByteString.Empty;

				[DebuggerNonUserCode]
				public static MessageParser<PluginData> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => SummaryMetadata.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string PluginName
				{
					get
					{
						return pluginName_;
					}
					set
					{
						pluginName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public ByteString Content
				{
					get
					{
						return content_;
					}
					set
					{
						content_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public PluginData()
				{
				}

				[DebuggerNonUserCode]
				public PluginData(PluginData other)
					: this()
				{
					pluginName_ = other.pluginName_;
					content_ = other.content_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public PluginData Clone()
				{
					return new PluginData(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as PluginData);
				}

				[DebuggerNonUserCode]
				public bool Equals(PluginData other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (PluginName != other.PluginName)
					{
						return false;
					}
					if (Content != other.Content)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (PluginName.Length != 0)
					{
						num ^= PluginName.GetHashCode();
					}
					if (Content.Length != 0)
					{
						num ^= ((object)Content).GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (PluginName.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(PluginName);
					}
					if (Content.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteBytes(Content);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (PluginName.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(PluginName);
					}
					if (Content.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeBytesSize(Content);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(PluginData other)
				{
					if (other != null)
					{
						if (other.PluginName.Length != 0)
						{
							PluginName = other.PluginName;
						}
						if (other.Content.Length != 0)
						{
							Content = other.Content;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							PluginName = input.ReadString();
							break;
						case 18u:
							Content = input.ReadBytes();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<SummaryMetadata> _parser = new MessageParser<SummaryMetadata>((Func<SummaryMetadata>)(() => new SummaryMetadata()));

		private UnknownFieldSet _unknownFields;

		public const int PluginDataFieldNumber = 1;

		private Types.PluginData pluginData_;

		public const int DisplayNameFieldNumber = 2;

		private string displayName_ = "";

		public const int SummaryDescriptionFieldNumber = 3;

		private string summaryDescription_ = "";

		public const int DataClassFieldNumber = 4;

		private DataClass dataClass_;

		[DebuggerNonUserCode]
		public static MessageParser<SummaryMetadata> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SummaryReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public Types.PluginData PluginData
		{
			get
			{
				return pluginData_;
			}
			set
			{
				pluginData_ = value;
			}
		}

		[DebuggerNonUserCode]
		public string DisplayName
		{
			get
			{
				return displayName_;
			}
			set
			{
				displayName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string SummaryDescription
		{
			get
			{
				return summaryDescription_;
			}
			set
			{
				summaryDescription_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public DataClass DataClass
		{
			get
			{
				return dataClass_;
			}
			set
			{
				dataClass_ = value;
			}
		}

		[DebuggerNonUserCode]
		public SummaryMetadata()
		{
		}

		[DebuggerNonUserCode]
		public SummaryMetadata(SummaryMetadata other)
			: this()
		{
			pluginData_ = ((other.pluginData_ != null) ? other.pluginData_.Clone() : null);
			displayName_ = other.displayName_;
			summaryDescription_ = other.summaryDescription_;
			dataClass_ = other.dataClass_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SummaryMetadata Clone()
		{
			return new SummaryMetadata(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SummaryMetadata);
		}

		[DebuggerNonUserCode]
		public bool Equals(SummaryMetadata other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!object.Equals(PluginData, other.PluginData))
			{
				return false;
			}
			if (DisplayName != other.DisplayName)
			{
				return false;
			}
			if (SummaryDescription != other.SummaryDescription)
			{
				return false;
			}
			if (DataClass != other.DataClass)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (pluginData_ != null)
			{
				num ^= PluginData.GetHashCode();
			}
			if (DisplayName.Length != 0)
			{
				num ^= DisplayName.GetHashCode();
			}
			if (SummaryDescription.Length != 0)
			{
				num ^= SummaryDescription.GetHashCode();
			}
			if (DataClass != DataClass.Unknown)
			{
				num ^= DataClass.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (pluginData_ != null)
			{
				output.WriteRawTag((byte)10);
				output.WriteMessage((IMessage)(object)PluginData);
			}
			if (DisplayName.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(DisplayName);
			}
			if (SummaryDescription.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(SummaryDescription);
			}
			if (DataClass != DataClass.Unknown)
			{
				output.WriteRawTag((byte)32);
				output.WriteEnum((int)DataClass);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (pluginData_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)PluginData);
			}
			if (DisplayName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(DisplayName);
			}
			if (SummaryDescription.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(SummaryDescription);
			}
			if (DataClass != DataClass.Unknown)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)DataClass);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SummaryMetadata other)
		{
			if (other == null)
			{
				return;
			}
			if (other.pluginData_ != null)
			{
				if (pluginData_ == null)
				{
					PluginData = new Types.PluginData();
				}
				PluginData.MergeFrom(other.PluginData);
			}
			if (other.DisplayName.Length != 0)
			{
				DisplayName = other.DisplayName;
			}
			if (other.SummaryDescription.Length != 0)
			{
				SummaryDescription = other.SummaryDescription;
			}
			if (other.DataClass != DataClass.Unknown)
			{
				DataClass = other.DataClass;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					if (pluginData_ == null)
					{
						PluginData = new Types.PluginData();
					}
					input.ReadMessage((IMessage)(object)PluginData);
					break;
				case 18u:
					DisplayName = input.ReadString();
					break;
				case 26u:
					SummaryDescription = input.ReadString();
					break;
				case 32u:
					DataClass = (DataClass)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class Summary : IMessage<Summary>, IMessage, IEquatable<Summary>, IDeepCloneable<Summary>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class Image : IMessage<Image>, IMessage, IEquatable<Image>, IDeepCloneable<Image>
			{
				private static readonly MessageParser<Image> _parser = new MessageParser<Image>((Func<Image>)(() => new Image()));

				private UnknownFieldSet _unknownFields;

				public const int HeightFieldNumber = 1;

				private int height_;

				public const int WidthFieldNumber = 2;

				private int width_;

				public const int ColorspaceFieldNumber = 3;

				private int colorspace_;

				public const int EncodedImageStringFieldNumber = 4;

				private ByteString encodedImageString_ = ByteString.Empty;

				[DebuggerNonUserCode]
				public static MessageParser<Image> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => Summary.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public int Height
				{
					get
					{
						return height_;
					}
					set
					{
						height_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int Width
				{
					get
					{
						return width_;
					}
					set
					{
						width_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int Colorspace
				{
					get
					{
						return colorspace_;
					}
					set
					{
						colorspace_ = value;
					}
				}

				[DebuggerNonUserCode]
				public ByteString EncodedImageString
				{
					get
					{
						return encodedImageString_;
					}
					set
					{
						encodedImageString_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public Image()
				{
				}

				[DebuggerNonUserCode]
				public Image(Image other)
					: this()
				{
					height_ = other.height_;
					width_ = other.width_;
					colorspace_ = other.colorspace_;
					encodedImageString_ = other.encodedImageString_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Image Clone()
				{
					return new Image(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Image);
				}

				[DebuggerNonUserCode]
				public bool Equals(Image other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Height != other.Height)
					{
						return false;
					}
					if (Width != other.Width)
					{
						return false;
					}
					if (Colorspace != other.Colorspace)
					{
						return false;
					}
					if (EncodedImageString != other.EncodedImageString)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Height != 0)
					{
						num ^= Height.GetHashCode();
					}
					if (Width != 0)
					{
						num ^= Width.GetHashCode();
					}
					if (Colorspace != 0)
					{
						num ^= Colorspace.GetHashCode();
					}
					if (EncodedImageString.Length != 0)
					{
						num ^= ((object)EncodedImageString).GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Height != 0)
					{
						output.WriteRawTag((byte)8);
						output.WriteInt32(Height);
					}
					if (Width != 0)
					{
						output.WriteRawTag((byte)16);
						output.WriteInt32(Width);
					}
					if (Colorspace != 0)
					{
						output.WriteRawTag((byte)24);
						output.WriteInt32(Colorspace);
					}
					if (EncodedImageString.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteBytes(EncodedImageString);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Height != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Height);
					}
					if (Width != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Width);
					}
					if (Colorspace != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Colorspace);
					}
					if (EncodedImageString.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeBytesSize(EncodedImageString);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Image other)
				{
					if (other != null)
					{
						if (other.Height != 0)
						{
							Height = other.Height;
						}
						if (other.Width != 0)
						{
							Width = other.Width;
						}
						if (other.Colorspace != 0)
						{
							Colorspace = other.Colorspace;
						}
						if (other.EncodedImageString.Length != 0)
						{
							EncodedImageString = other.EncodedImageString;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 8u:
							Height = input.ReadInt32();
							break;
						case 16u:
							Width = input.ReadInt32();
							break;
						case 24u:
							Colorspace = input.ReadInt32();
							break;
						case 34u:
							EncodedImageString = input.ReadBytes();
							break;
						}
					}
				}
			}

			public sealed class Audio : IMessage<Audio>, IMessage, IEquatable<Audio>, IDeepCloneable<Audio>
			{
				private static readonly MessageParser<Audio> _parser = new MessageParser<Audio>((Func<Audio>)(() => new Audio()));

				private UnknownFieldSet _unknownFields;

				public const int SampleRateFieldNumber = 1;

				private float sampleRate_;

				public const int NumChannelsFieldNumber = 2;

				private long numChannels_;

				public const int LengthFramesFieldNumber = 3;

				private long lengthFrames_;

				public const int EncodedAudioStringFieldNumber = 4;

				private ByteString encodedAudioString_ = ByteString.Empty;

				public const int ContentTypeFieldNumber = 5;

				private string contentType_ = "";

				[DebuggerNonUserCode]
				public static MessageParser<Audio> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => Summary.Descriptor.NestedTypes[1];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public float SampleRate
				{
					get
					{
						return sampleRate_;
					}
					set
					{
						sampleRate_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long NumChannels
				{
					get
					{
						return numChannels_;
					}
					set
					{
						numChannels_ = value;
					}
				}

				[DebuggerNonUserCode]
				public long LengthFrames
				{
					get
					{
						return lengthFrames_;
					}
					set
					{
						lengthFrames_ = value;
					}
				}

				[DebuggerNonUserCode]
				public ByteString EncodedAudioString
				{
					get
					{
						return encodedAudioString_;
					}
					set
					{
						encodedAudioString_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string ContentType
				{
					get
					{
						return contentType_;
					}
					set
					{
						contentType_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public Audio()
				{
				}

				[DebuggerNonUserCode]
				public Audio(Audio other)
					: this()
				{
					sampleRate_ = other.sampleRate_;
					numChannels_ = other.numChannels_;
					lengthFrames_ = other.lengthFrames_;
					encodedAudioString_ = other.encodedAudioString_;
					contentType_ = other.contentType_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Audio Clone()
				{
					return new Audio(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Audio);
				}

				[DebuggerNonUserCode]
				public bool Equals(Audio other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SampleRate, other.SampleRate))
					{
						return false;
					}
					if (NumChannels != other.NumChannels)
					{
						return false;
					}
					if (LengthFrames != other.LengthFrames)
					{
						return false;
					}
					if (EncodedAudioString != other.EncodedAudioString)
					{
						return false;
					}
					if (ContentType != other.ContentType)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (SampleRate != 0f)
					{
						num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SampleRate);
					}
					if (NumChannels != 0L)
					{
						num ^= NumChannels.GetHashCode();
					}
					if (LengthFrames != 0L)
					{
						num ^= LengthFrames.GetHashCode();
					}
					if (EncodedAudioString.Length != 0)
					{
						num ^= ((object)EncodedAudioString).GetHashCode();
					}
					if (ContentType.Length != 0)
					{
						num ^= ContentType.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (SampleRate != 0f)
					{
						output.WriteRawTag((byte)13);
						output.WriteFloat(SampleRate);
					}
					if (NumChannels != 0L)
					{
						output.WriteRawTag((byte)16);
						output.WriteInt64(NumChannels);
					}
					if (LengthFrames != 0L)
					{
						output.WriteRawTag((byte)24);
						output.WriteInt64(LengthFrames);
					}
					if (EncodedAudioString.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteBytes(EncodedAudioString);
					}
					if (ContentType.Length != 0)
					{
						output.WriteRawTag((byte)42);
						output.WriteString(ContentType);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (SampleRate != 0f)
					{
						num += 5;
					}
					if (NumChannels != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(NumChannels);
					}
					if (LengthFrames != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(LengthFrames);
					}
					if (EncodedAudioString.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeBytesSize(EncodedAudioString);
					}
					if (ContentType.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(ContentType);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Audio other)
				{
					if (other != null)
					{
						if (other.SampleRate != 0f)
						{
							SampleRate = other.SampleRate;
						}
						if (other.NumChannels != 0L)
						{
							NumChannels = other.NumChannels;
						}
						if (other.LengthFrames != 0L)
						{
							LengthFrames = other.LengthFrames;
						}
						if (other.EncodedAudioString.Length != 0)
						{
							EncodedAudioString = other.EncodedAudioString;
						}
						if (other.ContentType.Length != 0)
						{
							ContentType = other.ContentType;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 13u:
							SampleRate = input.ReadFloat();
							break;
						case 16u:
							NumChannels = input.ReadInt64();
							break;
						case 24u:
							LengthFrames = input.ReadInt64();
							break;
						case 34u:
							EncodedAudioString = input.ReadBytes();
							break;
						case 42u:
							ContentType = input.ReadString();
							break;
						}
					}
				}
			}

			public sealed class Value : IMessage<Value>, IMessage, IEquatable<Value>, IDeepCloneable<Value>
			{
				public enum ValueOneofCase
				{
					None = 0,
					SimpleValue = 2,
					ObsoleteOldStyleHistogram = 3,
					Image = 4,
					Histo = 5,
					Audio = 6,
					Tensor = 8
				}

				private static readonly MessageParser<Value> _parser = new MessageParser<Value>((Func<Value>)(() => new Value()));

				private UnknownFieldSet _unknownFields;

				public const int NodeNameFieldNumber = 7;

				private string nodeName_ = "";

				public const int TagFieldNumber = 1;

				private string tag_ = "";

				public const int MetadataFieldNumber = 9;

				private SummaryMetadata metadata_;

				public const int SimpleValueFieldNumber = 2;

				public const int ObsoleteOldStyleHistogramFieldNumber = 3;

				public const int ImageFieldNumber = 4;

				public const int HistoFieldNumber = 5;

				public const int AudioFieldNumber = 6;

				public const int TensorFieldNumber = 8;

				private object value_;

				private ValueOneofCase valueCase_;

				[DebuggerNonUserCode]
				public static MessageParser<Value> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => Summary.Descriptor.NestedTypes[2];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public string NodeName
				{
					get
					{
						return nodeName_;
					}
					set
					{
						nodeName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public string Tag
				{
					get
					{
						return tag_;
					}
					set
					{
						tag_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public SummaryMetadata Metadata
				{
					get
					{
						return metadata_;
					}
					set
					{
						metadata_ = value;
					}
				}

				[DebuggerNonUserCode]
				public float SimpleValue
				{
					get
					{
						if (valueCase_ != ValueOneofCase.SimpleValue)
						{
							return 0f;
						}
						return (float)value_;
					}
					set
					{
						value_ = value;
						valueCase_ = ValueOneofCase.SimpleValue;
					}
				}

				[DebuggerNonUserCode]
				public ByteString ObsoleteOldStyleHistogram
				{
					get
					{
						//IL_0015: Unknown result type (might be due to invalid IL or missing references)
						//IL_001b: Expected O, but got Unknown
						if (valueCase_ != ValueOneofCase.ObsoleteOldStyleHistogram)
						{
							return ByteString.Empty;
						}
						return (ByteString)value_;
					}
					set
					{
						value_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
						valueCase_ = ValueOneofCase.ObsoleteOldStyleHistogram;
					}
				}

				[DebuggerNonUserCode]
				public Image Image
				{
					get
					{
						if (valueCase_ != ValueOneofCase.Image)
						{
							return null;
						}
						return (Image)value_;
					}
					set
					{
						value_ = value;
						valueCase_ = ((value != null) ? ValueOneofCase.Image : ValueOneofCase.None);
					}
				}

				[DebuggerNonUserCode]
				public HistogramProto Histo
				{
					get
					{
						if (valueCase_ != ValueOneofCase.Histo)
						{
							return null;
						}
						return (HistogramProto)value_;
					}
					set
					{
						value_ = value;
						valueCase_ = ((value != null) ? ValueOneofCase.Histo : ValueOneofCase.None);
					}
				}

				[DebuggerNonUserCode]
				public Audio Audio
				{
					get
					{
						if (valueCase_ != ValueOneofCase.Audio)
						{
							return null;
						}
						return (Audio)value_;
					}
					set
					{
						value_ = value;
						valueCase_ = ((value != null) ? ValueOneofCase.Audio : ValueOneofCase.None);
					}
				}

				[DebuggerNonUserCode]
				public TensorProto Tensor
				{
					get
					{
						if (valueCase_ != ValueOneofCase.Tensor)
						{
							return null;
						}
						return (TensorProto)value_;
					}
					set
					{
						value_ = value;
						valueCase_ = ((value != null) ? ValueOneofCase.Tensor : ValueOneofCase.None);
					}
				}

				[DebuggerNonUserCode]
				public ValueOneofCase ValueCase => valueCase_;

				[DebuggerNonUserCode]
				public Value()
				{
				}

				[DebuggerNonUserCode]
				public Value(Value other)
					: this()
				{
					nodeName_ = other.nodeName_;
					tag_ = other.tag_;
					metadata_ = ((other.metadata_ != null) ? other.metadata_.Clone() : null);
					switch (other.ValueCase)
					{
					case ValueOneofCase.SimpleValue:
						SimpleValue = other.SimpleValue;
						break;
					case ValueOneofCase.ObsoleteOldStyleHistogram:
						ObsoleteOldStyleHistogram = other.ObsoleteOldStyleHistogram;
						break;
					case ValueOneofCase.Image:
						Image = other.Image.Clone();
						break;
					case ValueOneofCase.Histo:
						Histo = other.Histo.Clone();
						break;
					case ValueOneofCase.Audio:
						Audio = other.Audio.Clone();
						break;
					case ValueOneofCase.Tensor:
						Tensor = other.Tensor.Clone();
						break;
					}
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Value Clone()
				{
					return new Value(this);
				}

				[DebuggerNonUserCode]
				public void ClearValue()
				{
					valueCase_ = ValueOneofCase.None;
					value_ = null;
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Value);
				}

				[DebuggerNonUserCode]
				public bool Equals(Value other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (NodeName != other.NodeName)
					{
						return false;
					}
					if (Tag != other.Tag)
					{
						return false;
					}
					if (!object.Equals(Metadata, other.Metadata))
					{
						return false;
					}
					if (!ProtobufEqualityComparers.BitwiseSingleEqualityComparer.Equals(SimpleValue, other.SimpleValue))
					{
						return false;
					}
					if (ObsoleteOldStyleHistogram != other.ObsoleteOldStyleHistogram)
					{
						return false;
					}
					if (!object.Equals(Image, other.Image))
					{
						return false;
					}
					if (!object.Equals(Histo, other.Histo))
					{
						return false;
					}
					if (!object.Equals(Audio, other.Audio))
					{
						return false;
					}
					if (!object.Equals(Tensor, other.Tensor))
					{
						return false;
					}
					if (ValueCase != other.ValueCase)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (NodeName.Length != 0)
					{
						num ^= NodeName.GetHashCode();
					}
					if (Tag.Length != 0)
					{
						num ^= Tag.GetHashCode();
					}
					if (metadata_ != null)
					{
						num ^= Metadata.GetHashCode();
					}
					if (valueCase_ == ValueOneofCase.SimpleValue)
					{
						num ^= ProtobufEqualityComparers.BitwiseSingleEqualityComparer.GetHashCode(SimpleValue);
					}
					if (valueCase_ == ValueOneofCase.ObsoleteOldStyleHistogram)
					{
						num ^= ((object)ObsoleteOldStyleHistogram).GetHashCode();
					}
					if (valueCase_ == ValueOneofCase.Image)
					{
						num ^= Image.GetHashCode();
					}
					if (valueCase_ == ValueOneofCase.Histo)
					{
						num ^= Histo.GetHashCode();
					}
					if (valueCase_ == ValueOneofCase.Audio)
					{
						num ^= Audio.GetHashCode();
					}
					if (valueCase_ == ValueOneofCase.Tensor)
					{
						num ^= Tensor.GetHashCode();
					}
					num ^= (int)valueCase_;
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Tag.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(Tag);
					}
					if (valueCase_ == ValueOneofCase.SimpleValue)
					{
						output.WriteRawTag((byte)21);
						output.WriteFloat(SimpleValue);
					}
					if (valueCase_ == ValueOneofCase.ObsoleteOldStyleHistogram)
					{
						output.WriteRawTag((byte)26);
						output.WriteBytes(ObsoleteOldStyleHistogram);
					}
					if (valueCase_ == ValueOneofCase.Image)
					{
						output.WriteRawTag((byte)34);
						output.WriteMessage((IMessage)(object)Image);
					}
					if (valueCase_ == ValueOneofCase.Histo)
					{
						output.WriteRawTag((byte)42);
						output.WriteMessage((IMessage)(object)Histo);
					}
					if (valueCase_ == ValueOneofCase.Audio)
					{
						output.WriteRawTag((byte)50);
						output.WriteMessage((IMessage)(object)Audio);
					}
					if (NodeName.Length != 0)
					{
						output.WriteRawTag((byte)58);
						output.WriteString(NodeName);
					}
					if (valueCase_ == ValueOneofCase.Tensor)
					{
						output.WriteRawTag((byte)66);
						output.WriteMessage((IMessage)(object)Tensor);
					}
					if (metadata_ != null)
					{
						output.WriteRawTag((byte)74);
						output.WriteMessage((IMessage)(object)Metadata);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (NodeName.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(NodeName);
					}
					if (Tag.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Tag);
					}
					if (metadata_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Metadata);
					}
					if (valueCase_ == ValueOneofCase.SimpleValue)
					{
						num += 5;
					}
					if (valueCase_ == ValueOneofCase.ObsoleteOldStyleHistogram)
					{
						num += 1 + CodedOutputStream.ComputeBytesSize(ObsoleteOldStyleHistogram);
					}
					if (valueCase_ == ValueOneofCase.Image)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Image);
					}
					if (valueCase_ == ValueOneofCase.Histo)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Histo);
					}
					if (valueCase_ == ValueOneofCase.Audio)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Audio);
					}
					if (valueCase_ == ValueOneofCase.Tensor)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Tensor);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Value other)
				{
					if (other == null)
					{
						return;
					}
					if (other.NodeName.Length != 0)
					{
						NodeName = other.NodeName;
					}
					if (other.Tag.Length != 0)
					{
						Tag = other.Tag;
					}
					if (other.metadata_ != null)
					{
						if (metadata_ == null)
						{
							Metadata = new SummaryMetadata();
						}
						Metadata.MergeFrom(other.Metadata);
					}
					switch (other.ValueCase)
					{
					case ValueOneofCase.SimpleValue:
						SimpleValue = other.SimpleValue;
						break;
					case ValueOneofCase.ObsoleteOldStyleHistogram:
						ObsoleteOldStyleHistogram = other.ObsoleteOldStyleHistogram;
						break;
					case ValueOneofCase.Image:
						if (Image == null)
						{
							Image = new Image();
						}
						Image.MergeFrom(other.Image);
						break;
					case ValueOneofCase.Histo:
						if (Histo == null)
						{
							Histo = new HistogramProto();
						}
						Histo.MergeFrom(other.Histo);
						break;
					case ValueOneofCase.Audio:
						if (Audio == null)
						{
							Audio = new Audio();
						}
						Audio.MergeFrom(other.Audio);
						break;
					case ValueOneofCase.Tensor:
						if (Tensor == null)
						{
							Tensor = new TensorProto();
						}
						Tensor.MergeFrom(other.Tensor);
						break;
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							Tag = input.ReadString();
							break;
						case 21u:
							SimpleValue = input.ReadFloat();
							break;
						case 26u:
							ObsoleteOldStyleHistogram = input.ReadBytes();
							break;
						case 34u:
						{
							Image image = new Image();
							if (valueCase_ == ValueOneofCase.Image)
							{
								image.MergeFrom(Image);
							}
							input.ReadMessage((IMessage)(object)image);
							Image = image;
							break;
						}
						case 42u:
						{
							HistogramProto histogramProto = new HistogramProto();
							if (valueCase_ == ValueOneofCase.Histo)
							{
								histogramProto.MergeFrom(Histo);
							}
							input.ReadMessage((IMessage)(object)histogramProto);
							Histo = histogramProto;
							break;
						}
						case 50u:
						{
							Audio audio = new Audio();
							if (valueCase_ == ValueOneofCase.Audio)
							{
								audio.MergeFrom(Audio);
							}
							input.ReadMessage((IMessage)(object)audio);
							Audio = audio;
							break;
						}
						case 58u:
							NodeName = input.ReadString();
							break;
						case 66u:
						{
							TensorProto tensorProto = new TensorProto();
							if (valueCase_ == ValueOneofCase.Tensor)
							{
								tensorProto.MergeFrom(Tensor);
							}
							input.ReadMessage((IMessage)(object)tensorProto);
							Tensor = tensorProto;
							break;
						}
						case 74u:
							if (metadata_ == null)
							{
								Metadata = new SummaryMetadata();
							}
							input.ReadMessage((IMessage)(object)Metadata);
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<Summary> _parser = new MessageParser<Summary>((Func<Summary>)(() => new Summary()));

		private UnknownFieldSet _unknownFields;

		public const int ValueFieldNumber = 1;

		private static readonly FieldCodec<Types.Value> _repeated_value_codec = FieldCodec.ForMessage<Types.Value>(10u, Types.Value.Parser);

		private readonly RepeatedField<Types.Value> value_ = new RepeatedField<Types.Value>();

		[DebuggerNonUserCode]
		public static MessageParser<Summary> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => SummaryReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Value> Value => value_;

		[DebuggerNonUserCode]
		public Summary()
		{
		}

		[DebuggerNonUserCode]
		public Summary(Summary other)
			: this()
		{
			value_ = other.value_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public Summary Clone()
		{
			return new Summary(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as Summary);
		}

		[DebuggerNonUserCode]
		public bool Equals(Summary other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!value_.Equals(other.value_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)value_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			value_.WriteTo(output, _repeated_value_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += value_.CalculateSize(_repeated_value_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(Summary other)
		{
			if (other != null)
			{
				value_.Add((IEnumerable<Types.Value>)other.value_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					value_.AddEntriesFrom(input, _repeated_value_codec);
				}
			}
		}
	}
	public static class TensorReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TensorReflection()
		{
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdGVuc29yLnByb3RvEgt0ZW5z" + "b3Jib2FyZBoudGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3Jlc291cmNlX2hh" + "bmRsZS5wcm90bxordGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3RlbnNvcl9z" + "aGFwZS5wcm90bxokdGVuc29yYm9hcmQvY29tcGF0L3Byb3RvL3R5cGVzLnBy" + "b3RvIpAECgtUZW5zb3JQcm90bxIkCgVkdHlwZRgBIAEoDjIVLnRlbnNvcmJv" + "YXJkLkRhdGFUeXBlEjMKDHRlbnNvcl9zaGFwZRgCIAEoCzIdLnRlbnNvcmJv" + "YXJkLlRlbnNvclNoYXBlUHJvdG8SFgoOdmVyc2lvbl9udW1iZXIYAyABKAUS" + "FgoOdGVuc29yX2NvbnRlbnQYBCABKAwSFAoIaGFsZl92YWwYDSADKAVCAhAB" + "EhUKCWZsb2F0X3ZhbBgFIAMoAkICEAESFgoKZG91YmxlX3ZhbBgGIAMoAUIC" + "EAESEwoHaW50X3ZhbBgHIAMoBUICEAESEgoKc3RyaW5nX3ZhbBgIIAMoDBIY" + "CgxzY29tcGxleF92YWwYCSADKAJCAhABEhUKCWludDY0X3ZhbBgKIAMoA0IC" + "EAESFAoIYm9vbF92YWwYCyADKAhCAhABEhgKDGRjb21wbGV4X3ZhbBgMIAMo" + "AUICEAESPQoTcmVzb3VyY2VfaGFuZGxlX3ZhbBgOIAMoCzIgLnRlbnNvcmJv" + "YXJkLlJlc291cmNlSGFuZGxlUHJvdG8SOAoLdmFyaWFudF92YWwYDyADKAsy" + "Iy50ZW5zb3Jib2FyZC5WYXJpYW50VGVuc29yRGF0YVByb3RvEhYKCnVpbnQz" + "Ml92YWwYECADKA1CAhABEhYKCnVpbnQ2NF92YWwYESADKARCAhABImgKFlZh" + "cmlhbnRUZW5zb3JEYXRhUHJvdG8SEQoJdHlwZV9uYW1lGAEgASgJEhAKCG1l" + "dGFkYXRhGAIgASgMEikKB3RlbnNvcnMYAyADKAsyGC50ZW5zb3Jib2FyZC5U" + "ZW5zb3JQcm90b0J8ChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDFRlbnNv" + "clByb3Rvc1ABWk1naXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90" + "ZW5zb3JmbG93L2dvL2NvcmUvZnJhbWV3b3JrL3RlbnNvcl9nb19wcm90b/gB" + "AWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				ResourceHandleReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(TensorProto), (MessageParser)(object)TensorProto.Parser, new string[17]
				{
					"Dtype", "TensorShape", "VersionNumber", "TensorContent", "HalfVal", "FloatVal", "DoubleVal", "IntVal", "StringVal", "ScomplexVal",
					"Int64Val", "BoolVal", "DcomplexVal", "ResourceHandleVal", "VariantVal", "Uint32Val", "Uint64Val"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(VariantTensorDataProto), (MessageParser)(object)VariantTensorDataProto.Parser, new string[3] { "TypeName", "Metadata", "Tensors" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class TensorProto : IMessage<TensorProto>, IMessage, IEquatable<TensorProto>, IDeepCloneable<TensorProto>
	{
		private static readonly MessageParser<TensorProto> _parser = new MessageParser<TensorProto>((Func<TensorProto>)(() => new TensorProto()));

		private UnknownFieldSet _unknownFields;

		public const int DtypeFieldNumber = 1;

		private DataType dtype_;

		public const int TensorShapeFieldNumber = 2;

		private TensorShapeProto tensorShape_;

		public const int VersionNumberFieldNumber = 3;

		private int versionNumber_;

		public const int TensorContentFieldNumber = 4;

		private ByteString tensorContent_ = ByteString.Empty;

		public const int HalfValFieldNumber = 13;

		private static readonly FieldCodec<int> _repeated_halfVal_codec = FieldCodec.ForInt32(106u);

		private readonly RepeatedField<int> halfVal_ = new RepeatedField<int>();

		public const int FloatValFieldNumber = 5;

		private static readonly FieldCodec<float> _repeated_floatVal_codec = FieldCodec.ForFloat(42u);

		private readonly RepeatedField<float> floatVal_ = new RepeatedField<float>();

		public const int DoubleValFieldNumber = 6;

		private static readonly FieldCodec<double> _repeated_doubleVal_codec = FieldCodec.ForDouble(50u);

		private readonly RepeatedField<double> doubleVal_ = new RepeatedField<double>();

		public const int IntValFieldNumber = 7;

		private static readonly FieldCodec<int> _repeated_intVal_codec = FieldCodec.ForInt32(58u);

		private readonly RepeatedField<int> intVal_ = new RepeatedField<int>();

		public const int StringValFieldNumber = 8;

		private static readonly FieldCodec<ByteString> _repeated_stringVal_codec = FieldCodec.ForBytes(66u);

		private readonly RepeatedField<ByteString> stringVal_ = new RepeatedField<ByteString>();

		public const int ScomplexValFieldNumber = 9;

		private static readonly FieldCodec<float> _repeated_scomplexVal_codec = FieldCodec.ForFloat(74u);

		private readonly RepeatedField<float> scomplexVal_ = new RepeatedField<float>();

		public const int Int64ValFieldNumber = 10;

		private static readonly FieldCodec<long> _repeated_int64Val_codec = FieldCodec.ForInt64(82u);

		private readonly RepeatedField<long> int64Val_ = new RepeatedField<long>();

		public const int BoolValFieldNumber = 11;

		private static readonly FieldCodec<bool> _repeated_boolVal_codec = FieldCodec.ForBool(90u);

		private readonly RepeatedField<bool> boolVal_ = new RepeatedField<bool>();

		public const int DcomplexValFieldNumber = 12;

		private static readonly FieldCodec<double> _repeated_dcomplexVal_codec = FieldCodec.ForDouble(98u);

		private readonly RepeatedField<double> dcomplexVal_ = new RepeatedField<double>();

		public const int ResourceHandleValFieldNumber = 14;

		private static readonly FieldCodec<ResourceHandleProto> _repeated_resourceHandleVal_codec = FieldCodec.ForMessage<ResourceHandleProto>(114u, ResourceHandleProto.Parser);

		private readonly RepeatedField<ResourceHandleProto> resourceHandleVal_ = new RepeatedField<ResourceHandleProto>();

		public const int VariantValFieldNumber = 15;

		private static readonly FieldCodec<VariantTensorDataProto> _repeated_variantVal_codec = FieldCodec.ForMessage<VariantTensorDataProto>(122u, VariantTensorDataProto.Parser);

		private readonly RepeatedField<VariantTensorDataProto> variantVal_ = new RepeatedField<VariantTensorDataProto>();

		public const int Uint32ValFieldNumber = 16;

		private static readonly FieldCodec<uint> _repeated_uint32Val_codec = FieldCodec.ForUInt32(130u);

		private readonly RepeatedField<uint> uint32Val_ = new RepeatedField<uint>();

		public const int Uint64ValFieldNumber = 17;

		private static readonly FieldCodec<ulong> _repeated_uint64Val_codec = FieldCodec.ForUInt64(138u);

		private readonly RepeatedField<ulong> uint64Val_ = new RepeatedField<ulong>();

		[DebuggerNonUserCode]
		public static MessageParser<TensorProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TensorReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public DataType Dtype
		{
			get
			{
				return dtype_;
			}
			set
			{
				dtype_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto TensorShape
		{
			get
			{
				return tensorShape_;
			}
			set
			{
				tensorShape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int VersionNumber
		{
			get
			{
				return versionNumber_;
			}
			set
			{
				versionNumber_ = value;
			}
		}

		[DebuggerNonUserCode]
		public ByteString TensorContent
		{
			get
			{
				return tensorContent_;
			}
			set
			{
				tensorContent_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<int> HalfVal => halfVal_;

		[DebuggerNonUserCode]
		public RepeatedField<float> FloatVal => floatVal_;

		[DebuggerNonUserCode]
		public RepeatedField<double> DoubleVal => doubleVal_;

		[DebuggerNonUserCode]
		public RepeatedField<int> IntVal => intVal_;

		[DebuggerNonUserCode]
		public RepeatedField<ByteString> StringVal => stringVal_;

		[DebuggerNonUserCode]
		public RepeatedField<float> ScomplexVal => scomplexVal_;

		[DebuggerNonUserCode]
		public RepeatedField<long> Int64Val => int64Val_;

		[DebuggerNonUserCode]
		public RepeatedField<bool> BoolVal => boolVal_;

		[DebuggerNonUserCode]
		public RepeatedField<double> DcomplexVal => dcomplexVal_;

		[DebuggerNonUserCode]
		public RepeatedField<ResourceHandleProto> ResourceHandleVal => resourceHandleVal_;

		[DebuggerNonUserCode]
		public RepeatedField<VariantTensorDataProto> VariantVal => variantVal_;

		[DebuggerNonUserCode]
		public RepeatedField<uint> Uint32Val => uint32Val_;

		[DebuggerNonUserCode]
		public RepeatedField<ulong> Uint64Val => uint64Val_;

		[DebuggerNonUserCode]
		public TensorProto()
		{
		}

		[DebuggerNonUserCode]
		public TensorProto(TensorProto other)
			: this()
		{
			dtype_ = other.dtype_;
			tensorShape_ = ((other.tensorShape_ != null) ? other.tensorShape_.Clone() : null);
			versionNumber_ = other.versionNumber_;
			tensorContent_ = other.tensorContent_;
			halfVal_ = other.halfVal_.Clone();
			floatVal_ = other.floatVal_.Clone();
			doubleVal_ = other.doubleVal_.Clone();
			intVal_ = other.intVal_.Clone();
			stringVal_ = other.stringVal_.Clone();
			scomplexVal_ = other.scomplexVal_.Clone();
			int64Val_ = other.int64Val_.Clone();
			boolVal_ = other.boolVal_.Clone();
			dcomplexVal_ = other.dcomplexVal_.Clone();
			resourceHandleVal_ = other.resourceHandleVal_.Clone();
			variantVal_ = other.variantVal_.Clone();
			uint32Val_ = other.uint32Val_.Clone();
			uint64Val_ = other.uint64Val_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TensorProto Clone()
		{
			return new TensorProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TensorProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(TensorProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Dtype != other.Dtype)
			{
				return false;
			}
			if (!object.Equals(TensorShape, other.TensorShape))
			{
				return false;
			}
			if (VersionNumber != other.VersionNumber)
			{
				return false;
			}
			if (TensorContent != other.TensorContent)
			{
				return false;
			}
			if (!halfVal_.Equals(other.halfVal_))
			{
				return false;
			}
			if (!floatVal_.Equals(other.floatVal_))
			{
				return false;
			}
			if (!doubleVal_.Equals(other.doubleVal_))
			{
				return false;
			}
			if (!intVal_.Equals(other.intVal_))
			{
				return false;
			}
			if (!stringVal_.Equals(other.stringVal_))
			{
				return false;
			}
			if (!scomplexVal_.Equals(other.scomplexVal_))
			{
				return false;
			}
			if (!int64Val_.Equals(other.int64Val_))
			{
				return false;
			}
			if (!boolVal_.Equals(other.boolVal_))
			{
				return false;
			}
			if (!dcomplexVal_.Equals(other.dcomplexVal_))
			{
				return false;
			}
			if (!resourceHandleVal_.Equals(other.resourceHandleVal_))
			{
				return false;
			}
			if (!variantVal_.Equals(other.variantVal_))
			{
				return false;
			}
			if (!uint32Val_.Equals(other.uint32Val_))
			{
				return false;
			}
			if (!uint64Val_.Equals(other.uint64Val_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Dtype != DataType.DtInvalid)
			{
				num ^= Dtype.GetHashCode();
			}
			if (tensorShape_ != null)
			{
				num ^= TensorShape.GetHashCode();
			}
			if (VersionNumber != 0)
			{
				num ^= VersionNumber.GetHashCode();
			}
			if (TensorContent.Length != 0)
			{
				num ^= ((object)TensorContent).GetHashCode();
			}
			num ^= ((object)halfVal_).GetHashCode();
			num ^= ((object)floatVal_).GetHashCode();
			num ^= ((object)doubleVal_).GetHashCode();
			num ^= ((object)intVal_).GetHashCode();
			num ^= ((object)stringVal_).GetHashCode();
			num ^= ((object)scomplexVal_).GetHashCode();
			num ^= ((object)int64Val_).GetHashCode();
			num ^= ((object)boolVal_).GetHashCode();
			num ^= ((object)dcomplexVal_).GetHashCode();
			num ^= ((object)resourceHandleVal_).GetHashCode();
			num ^= ((object)variantVal_).GetHashCode();
			num ^= ((object)uint32Val_).GetHashCode();
			num ^= ((object)uint64Val_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Dtype != DataType.DtInvalid)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)Dtype);
			}
			if (tensorShape_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)TensorShape);
			}
			if (VersionNumber != 0)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt32(VersionNumber);
			}
			if (TensorContent.Length != 0)
			{
				output.WriteRawTag((byte)34);
				output.WriteBytes(TensorContent);
			}
			floatVal_.WriteTo(output, _repeated_floatVal_codec);
			doubleVal_.WriteTo(output, _repeated_doubleVal_codec);
			intVal_.WriteTo(output, _repeated_intVal_codec);
			stringVal_.WriteTo(output, _repeated_stringVal_codec);
			scomplexVal_.WriteTo(output, _repeated_scomplexVal_codec);
			int64Val_.WriteTo(output, _repeated_int64Val_codec);
			boolVal_.WriteTo(output, _repeated_boolVal_codec);
			dcomplexVal_.WriteTo(output, _repeated_dcomplexVal_codec);
			halfVal_.WriteTo(output, _repeated_halfVal_codec);
			resourceHandleVal_.WriteTo(output, _repeated_resourceHandleVal_codec);
			variantVal_.WriteTo(output, _repeated_variantVal_codec);
			uint32Val_.WriteTo(output, _repeated_uint32Val_codec);
			uint64Val_.WriteTo(output, _repeated_uint64Val_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Dtype != DataType.DtInvalid)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
			}
			if (tensorShape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)TensorShape);
			}
			if (VersionNumber != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(VersionNumber);
			}
			if (TensorContent.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(TensorContent);
			}
			num += halfVal_.CalculateSize(_repeated_halfVal_codec);
			num += floatVal_.CalculateSize(_repeated_floatVal_codec);
			num += doubleVal_.CalculateSize(_repeated_doubleVal_codec);
			num += intVal_.CalculateSize(_repeated_intVal_codec);
			num += stringVal_.CalculateSize(_repeated_stringVal_codec);
			num += scomplexVal_.CalculateSize(_repeated_scomplexVal_codec);
			num += int64Val_.CalculateSize(_repeated_int64Val_codec);
			num += boolVal_.CalculateSize(_repeated_boolVal_codec);
			num += dcomplexVal_.CalculateSize(_repeated_dcomplexVal_codec);
			num += resourceHandleVal_.CalculateSize(_repeated_resourceHandleVal_codec);
			num += variantVal_.CalculateSize(_repeated_variantVal_codec);
			num += uint32Val_.CalculateSize(_repeated_uint32Val_codec);
			num += uint64Val_.CalculateSize(_repeated_uint64Val_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TensorProto other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Dtype != DataType.DtInvalid)
			{
				Dtype = other.Dtype;
			}
			if (other.tensorShape_ != null)
			{
				if (tensorShape_ == null)
				{
					TensorShape = new TensorShapeProto();
				}
				TensorShape.MergeFrom(other.TensorShape);
			}
			if (other.VersionNumber != 0)
			{
				VersionNumber = other.VersionNumber;
			}
			if (other.TensorContent.Length != 0)
			{
				TensorContent = other.TensorContent;
			}
			halfVal_.Add((IEnumerable<int>)other.halfVal_);
			floatVal_.Add((IEnumerable<float>)other.floatVal_);
			doubleVal_.Add((IEnumerable<double>)other.doubleVal_);
			intVal_.Add((IEnumerable<int>)other.intVal_);
			stringVal_.Add((IEnumerable<ByteString>)other.stringVal_);
			scomplexVal_.Add((IEnumerable<float>)other.scomplexVal_);
			int64Val_.Add((IEnumerable<long>)other.int64Val_);
			boolVal_.Add((IEnumerable<bool>)other.boolVal_);
			dcomplexVal_.Add((IEnumerable<double>)other.dcomplexVal_);
			resourceHandleVal_.Add((IEnumerable<ResourceHandleProto>)other.resourceHandleVal_);
			variantVal_.Add((IEnumerable<VariantTensorDataProto>)other.variantVal_);
			uint32Val_.Add((IEnumerable<uint>)other.uint32Val_);
			uint64Val_.Add((IEnumerable<ulong>)other.uint64Val_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Dtype = (DataType)input.ReadEnum();
					break;
				case 18u:
					if (tensorShape_ == null)
					{
						TensorShape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)TensorShape);
					break;
				case 24u:
					VersionNumber = input.ReadInt32();
					break;
				case 34u:
					TensorContent = input.ReadBytes();
					break;
				case 42u:
				case 45u:
					floatVal_.AddEntriesFrom(input, _repeated_floatVal_codec);
					break;
				case 49u:
				case 50u:
					doubleVal_.AddEntriesFrom(input, _repeated_doubleVal_codec);
					break;
				case 56u:
				case 58u:
					intVal_.AddEntriesFrom(input, _repeated_intVal_codec);
					break;
				case 66u:
					stringVal_.AddEntriesFrom(input, _repeated_stringVal_codec);
					break;
				case 74u:
				case 77u:
					scomplexVal_.AddEntriesFrom(input, _repeated_scomplexVal_codec);
					break;
				case 80u:
				case 82u:
					int64Val_.AddEntriesFrom(input, _repeated_int64Val_codec);
					break;
				case 88u:
				case 90u:
					boolVal_.AddEntriesFrom(input, _repeated_boolVal_codec);
					break;
				case 97u:
				case 98u:
					dcomplexVal_.AddEntriesFrom(input, _repeated_dcomplexVal_codec);
					break;
				case 104u:
				case 106u:
					halfVal_.AddEntriesFrom(input, _repeated_halfVal_codec);
					break;
				case 114u:
					resourceHandleVal_.AddEntriesFrom(input, _repeated_resourceHandleVal_codec);
					break;
				case 122u:
					variantVal_.AddEntriesFrom(input, _repeated_variantVal_codec);
					break;
				case 128u:
				case 130u:
					uint32Val_.AddEntriesFrom(input, _repeated_uint32Val_codec);
					break;
				case 136u:
				case 138u:
					uint64Val_.AddEntriesFrom(input, _repeated_uint64Val_codec);
					break;
				}
			}
		}
	}
	public sealed class VariantTensorDataProto : IMessage<VariantTensorDataProto>, IMessage, IEquatable<VariantTensorDataProto>, IDeepCloneable<VariantTensorDataProto>
	{
		private static readonly MessageParser<VariantTensorDataProto> _parser = new MessageParser<VariantTensorDataProto>((Func<VariantTensorDataProto>)(() => new VariantTensorDataProto()));

		private UnknownFieldSet _unknownFields;

		public const int TypeNameFieldNumber = 1;

		private string typeName_ = "";

		public const int MetadataFieldNumber = 2;

		private ByteString metadata_ = ByteString.Empty;

		public const int TensorsFieldNumber = 3;

		private static readonly FieldCodec<TensorProto> _repeated_tensors_codec = FieldCodec.ForMessage<TensorProto>(26u, TensorProto.Parser);

		private readonly RepeatedField<TensorProto> tensors_ = new RepeatedField<TensorProto>();

		[DebuggerNonUserCode]
		public static MessageParser<VariantTensorDataProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TensorReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string TypeName
		{
			get
			{
				return typeName_;
			}
			set
			{
				typeName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public ByteString Metadata
		{
			get
			{
				return metadata_;
			}
			set
			{
				metadata_ = ProtoPreconditions.CheckNotNull<ByteString>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<TensorProto> Tensors => tensors_;

		[DebuggerNonUserCode]
		public VariantTensorDataProto()
		{
		}

		[DebuggerNonUserCode]
		public VariantTensorDataProto(VariantTensorDataProto other)
			: this()
		{
			typeName_ = other.typeName_;
			metadata_ = other.metadata_;
			tensors_ = other.tensors_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public VariantTensorDataProto Clone()
		{
			return new VariantTensorDataProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as VariantTensorDataProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(VariantTensorDataProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (TypeName != other.TypeName)
			{
				return false;
			}
			if (Metadata != other.Metadata)
			{
				return false;
			}
			if (!tensors_.Equals(other.tensors_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (TypeName.Length != 0)
			{
				num ^= TypeName.GetHashCode();
			}
			if (Metadata.Length != 0)
			{
				num ^= ((object)Metadata).GetHashCode();
			}
			num ^= ((object)tensors_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (TypeName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(TypeName);
			}
			if (Metadata.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteBytes(Metadata);
			}
			tensors_.WriteTo(output, _repeated_tensors_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (TypeName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(TypeName);
			}
			if (Metadata.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeBytesSize(Metadata);
			}
			num += tensors_.CalculateSize(_repeated_tensors_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(VariantTensorDataProto other)
		{
			if (other != null)
			{
				if (other.TypeName.Length != 0)
				{
					TypeName = other.TypeName;
				}
				if (other.Metadata.Length != 0)
				{
					Metadata = other.Metadata;
				}
				tensors_.Add((IEnumerable<TensorProto>)other.tensors_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					TypeName = input.ReadString();
					break;
				case 18u:
					Metadata = input.ReadBytes();
					break;
				case 26u:
					tensors_.AddEntriesFrom(input, _repeated_tensors_codec);
					break;
				}
			}
		}
	}
	public static class TensorDescriptionReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TensorDescriptionReflection()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CjF0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdGVuc29yX2Rlc2NyaXB0aW9u" + "LnByb3RvEgt0ZW5zb3Jib2FyZBo1dGVuc29yYm9hcmQvY29tcGF0L3Byb3Rv" + "L2FsbG9jYXRpb25fZGVzY3JpcHRpb24ucHJvdG8aK3RlbnNvcmJvYXJkL2Nv" + "bXBhdC9wcm90by90ZW5zb3Jfc2hhcGUucHJvdG8aJHRlbnNvcmJvYXJkL2Nv" + "bXBhdC9wcm90by90eXBlcy5wcm90byKrAQoRVGVuc29yRGVzY3JpcHRpb24S" + "JAoFZHR5cGUYASABKA4yFS50ZW5zb3Jib2FyZC5EYXRhVHlwZRIsCgVzaGFw" + "ZRgCIAEoCzIdLnRlbnNvcmJvYXJkLlRlbnNvclNoYXBlUHJvdG8SQgoWYWxs" + "b2NhdGlvbl9kZXNjcmlwdGlvbhgEIAEoCzIiLnRlbnNvcmJvYXJkLkFsbG9j" + "YXRpb25EZXNjcmlwdGlvbkKTAQoYb3JnLnRlbnNvcmZsb3cuZnJhbWV3b3Jr" + "QhdUZW5zb3JEZXNjcmlwdGlvblByb3Rvc1ABWllnaXRodWIuY29tL3RlbnNv" + "cmZsb3cvdGVuc29yZmxvdy90ZW5zb3JmbG93L2dvL2NvcmUvZnJhbWV3b3Jr" + "L3RlbnNvcl9kZXNjcmlwdGlvbl9nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[3]
			{
				AllocationDescriptionReflection.Descriptor,
				TensorShapeReflection.Descriptor,
				TypesReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(TensorDescription), (MessageParser)(object)TensorDescription.Parser, new string[3] { "Dtype", "Shape", "AllocationDescription" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class TensorDescription : IMessage<TensorDescription>, IMessage, IEquatable<TensorDescription>, IDeepCloneable<TensorDescription>
	{
		private static readonly MessageParser<TensorDescription> _parser = new MessageParser<TensorDescription>((Func<TensorDescription>)(() => new TensorDescription()));

		private UnknownFieldSet _unknownFields;

		public const int DtypeFieldNumber = 1;

		private DataType dtype_;

		public const int ShapeFieldNumber = 2;

		private TensorShapeProto shape_;

		public const int AllocationDescriptionFieldNumber = 4;

		private AllocationDescription allocationDescription_;

		[DebuggerNonUserCode]
		public static MessageParser<TensorDescription> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TensorDescriptionReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public DataType Dtype
		{
			get
			{
				return dtype_;
			}
			set
			{
				dtype_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto Shape
		{
			get
			{
				return shape_;
			}
			set
			{
				shape_ = value;
			}
		}

		[DebuggerNonUserCode]
		public AllocationDescription AllocationDescription
		{
			get
			{
				return allocationDescription_;
			}
			set
			{
				allocationDescription_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorDescription()
		{
		}

		[DebuggerNonUserCode]
		public TensorDescription(TensorDescription other)
			: this()
		{
			dtype_ = other.dtype_;
			shape_ = ((other.shape_ != null) ? other.shape_.Clone() : null);
			allocationDescription_ = ((other.allocationDescription_ != null) ? other.allocationDescription_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TensorDescription Clone()
		{
			return new TensorDescription(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TensorDescription);
		}

		[DebuggerNonUserCode]
		public bool Equals(TensorDescription other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Dtype != other.Dtype)
			{
				return false;
			}
			if (!object.Equals(Shape, other.Shape))
			{
				return false;
			}
			if (!object.Equals(AllocationDescription, other.AllocationDescription))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Dtype != DataType.DtInvalid)
			{
				num ^= Dtype.GetHashCode();
			}
			if (shape_ != null)
			{
				num ^= Shape.GetHashCode();
			}
			if (allocationDescription_ != null)
			{
				num ^= AllocationDescription.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Dtype != DataType.DtInvalid)
			{
				output.WriteRawTag((byte)8);
				output.WriteEnum((int)Dtype);
			}
			if (shape_ != null)
			{
				output.WriteRawTag((byte)18);
				output.WriteMessage((IMessage)(object)Shape);
			}
			if (allocationDescription_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)AllocationDescription);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Dtype != DataType.DtInvalid)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Dtype);
			}
			if (shape_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Shape);
			}
			if (allocationDescription_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)AllocationDescription);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TensorDescription other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Dtype != DataType.DtInvalid)
			{
				Dtype = other.Dtype;
			}
			if (other.shape_ != null)
			{
				if (shape_ == null)
				{
					Shape = new TensorShapeProto();
				}
				Shape.MergeFrom(other.Shape);
			}
			if (other.allocationDescription_ != null)
			{
				if (allocationDescription_ == null)
				{
					AllocationDescription = new AllocationDescription();
				}
				AllocationDescription.MergeFrom(other.AllocationDescription);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Dtype = (DataType)input.ReadEnum();
					break;
				case 18u:
					if (shape_ == null)
					{
						Shape = new TensorShapeProto();
					}
					input.ReadMessage((IMessage)(object)Shape);
					break;
				case 34u:
					if (allocationDescription_ == null)
					{
						AllocationDescription = new AllocationDescription();
					}
					input.ReadMessage((IMessage)(object)AllocationDescription);
					break;
				}
			}
		}
	}
	public static class TensorShapeReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TensorShapeReflection()
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cit0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdGVuc29yX3NoYXBlLnByb3Rv" + "Egt0ZW5zb3Jib2FyZCJ7ChBUZW5zb3JTaGFwZVByb3RvEi4KA2RpbRgCIAMo" + "CzIhLnRlbnNvcmJvYXJkLlRlbnNvclNoYXBlUHJvdG8uRGltEhQKDHVua25v" + "d25fcmFuaxgDIAEoCBohCgNEaW0SDAoEc2l6ZRgBIAEoAxIMCgRuYW1lGAIg" + "ASgJQocBChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCEVRlbnNvclNoYXBl" + "UHJvdG9zUAFaU2dpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3JmbG93L3Rl" + "bnNvcmZsb3cvZ28vY29yZS9mcmFtZXdvcmsvdGVuc29yX3NoYXBlX2dvX3By" + "b3Rv+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(TensorShapeProto), (MessageParser)(object)TensorShapeProto.Parser, new string[2] { "Dim", "UnknownRank" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(TensorShapeProto.Types.Dim), (MessageParser)(object)TensorShapeProto.Types.Dim.Parser, new string[2] { "Size", "Name" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				})
			}));
		}
	}
	public sealed class TensorShapeProto : IMessage<TensorShapeProto>, IMessage, IEquatable<TensorShapeProto>, IDeepCloneable<TensorShapeProto>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class Dim : IMessage<Dim>, IMessage, IEquatable<Dim>, IDeepCloneable<Dim>
			{
				private static readonly MessageParser<Dim> _parser = new MessageParser<Dim>((Func<Dim>)(() => new Dim()));

				private UnknownFieldSet _unknownFields;

				public const int SizeFieldNumber = 1;

				private long size_;

				public const int NameFieldNumber = 2;

				private string name_ = "";

				[DebuggerNonUserCode]
				public static MessageParser<Dim> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => TensorShapeProto.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public long Size
				{
					get
					{
						return size_;
					}
					set
					{
						size_ = value;
					}
				}

				[DebuggerNonUserCode]
				public string Name
				{
					get
					{
						return name_;
					}
					set
					{
						name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public Dim()
				{
				}

				[DebuggerNonUserCode]
				public Dim(Dim other)
					: this()
				{
					size_ = other.size_;
					name_ = other.name_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Dim Clone()
				{
					return new Dim(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Dim);
				}

				[DebuggerNonUserCode]
				public bool Equals(Dim other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (Size != other.Size)
					{
						return false;
					}
					if (Name != other.Name)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (Size != 0L)
					{
						num ^= Size.GetHashCode();
					}
					if (Name.Length != 0)
					{
						num ^= Name.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (Size != 0L)
					{
						output.WriteRawTag((byte)8);
						output.WriteInt64(Size);
					}
					if (Name.Length != 0)
					{
						output.WriteRawTag((byte)18);
						output.WriteString(Name);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (Size != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(Size);
					}
					if (Name.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Name);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Dim other)
				{
					if (other != null)
					{
						if (other.Size != 0L)
						{
							Size = other.Size;
						}
						if (other.Name.Length != 0)
						{
							Name = other.Name;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 8u:
							Size = input.ReadInt64();
							break;
						case 18u:
							Name = input.ReadString();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<TensorShapeProto> _parser = new MessageParser<TensorShapeProto>((Func<TensorShapeProto>)(() => new TensorShapeProto()));

		private UnknownFieldSet _unknownFields;

		public const int DimFieldNumber = 2;

		private static readonly FieldCodec<Types.Dim> _repeated_dim_codec = FieldCodec.ForMessage<Types.Dim>(18u, Types.Dim.Parser);

		private readonly RepeatedField<Types.Dim> dim_ = new RepeatedField<Types.Dim>();

		public const int UnknownRankFieldNumber = 3;

		private bool unknownRank_;

		[DebuggerNonUserCode]
		public static MessageParser<TensorShapeProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TensorShapeReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Dim> Dim => dim_;

		[DebuggerNonUserCode]
		public bool UnknownRank
		{
			get
			{
				return unknownRank_;
			}
			set
			{
				unknownRank_ = value;
			}
		}

		[DebuggerNonUserCode]
		public TensorShapeProto()
		{
		}

		[DebuggerNonUserCode]
		public TensorShapeProto(TensorShapeProto other)
			: this()
		{
			dim_ = other.dim_.Clone();
			unknownRank_ = other.unknownRank_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TensorShapeProto Clone()
		{
			return new TensorShapeProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TensorShapeProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(TensorShapeProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!dim_.Equals(other.dim_))
			{
				return false;
			}
			if (UnknownRank != other.UnknownRank)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)dim_).GetHashCode();
			if (UnknownRank)
			{
				num ^= UnknownRank.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			dim_.WriteTo(output, _repeated_dim_codec);
			if (UnknownRank)
			{
				output.WriteRawTag((byte)24);
				output.WriteBool(UnknownRank);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += dim_.CalculateSize(_repeated_dim_codec);
			if (UnknownRank)
			{
				num += 2;
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TensorShapeProto other)
		{
			if (other != null)
			{
				dim_.Add((IEnumerable<Types.Dim>)other.dim_);
				if (other.UnknownRank)
				{
					UnknownRank = other.UnknownRank;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 18u:
					dim_.AddEntriesFrom(input, _repeated_dim_codec);
					break;
				case 24u:
					UnknownRank = input.ReadBool();
					break;
				}
			}
		}
	}
	public static class TfprofLogReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TfprofLogReflection()
		{
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Expected O, but got Unknown
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0367: Unknown result type (might be due to invalid IL or missing references)
			//IL_036d: Expected O, but got Unknown
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Expected O, but got Unknown
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f1: Expected O, but got Unknown
			//IL_0499: Unknown result type (might be due to invalid IL or missing references)
			//IL_049f: Expected O, but got Unknown
			//IL_04ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0505: Expected O, but got Unknown
			//IL_0528: Unknown result type (might be due to invalid IL or missing references)
			//IL_052e: Expected O, but got Unknown
			//IL_05a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05af: Expected O, but got Unknown
			//IL_05d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d8: Expected O, but got Unknown
			//IL_0604: Unknown result type (might be due to invalid IL or missing references)
			//IL_060a: Expected O, but got Unknown
			//IL_060a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0614: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdGZwcm9mX2xvZy5wcm90bxIL" + "dGVuc29yYm9hcmQaKXRlbnNvcmJvYXJkL2NvbXBhdC9wcm90by9hdHRyX3Zh" + "bHVlLnByb3RvGil0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vc3RlcF9zdGF0" + "cy5wcm90byLZAQoHQ29kZURlZhIqCgZ0cmFjZXMYASADKAsyGi50ZW5zb3Ji" + "b2FyZC5Db2RlRGVmLlRyYWNlGqEBCgVUcmFjZRIQCgRmaWxlGAEgASgJQgIY" + "ARIPCgdmaWxlX2lkGAYgASgDEg4KBmxpbmVubxgCIAEoBRIUCghmdW5jdGlv" + "bhgDIAEoCUICGAESEwoLZnVuY3Rpb25faWQYByABKAMSEAoEbGluZRgEIAEo" + "CUICGAESDwoHbGluZV9pZBgIIAEoAxIXCg9mdW5jX3N0YXJ0X2xpbmUYBSAB" + "KAUiZAoKT3BMb2dFbnRyeRIMCgRuYW1lGAEgASgJEhEKCWZsb2F0X29wcxgC" + "IAEoAxINCgV0eXBlcxgDIAMoCRImCghjb2RlX2RlZhgEIAEoCzIULnRlbnNv" + "cmJvYXJkLkNvZGVEZWYirAEKCk9wTG9nUHJvdG8SLAoLbG9nX2VudHJpZXMY" + "ASADKAsyFy50ZW5zb3Jib2FyZC5PcExvZ0VudHJ5Ej0KDGlkX3RvX3N0cmlu" + "ZxgCIAMoCzInLnRlbnNvcmJvYXJkLk9wTG9nUHJvdG8uSWRUb1N0cmluZ0Vu" + "dHJ5GjEKD0lkVG9TdHJpbmdFbnRyeRILCgNrZXkYASABKAMSDQoFdmFsdWUY" + "AiABKAk6AjgBIsICCgxQcm9maWxlUHJvdG8SMwoFbm9kZXMYASADKAsyJC50" + "ZW5zb3Jib2FyZC5Qcm9maWxlUHJvdG8uTm9kZXNFbnRyeRIRCgloYXNfdHJh" + "Y2UYAiABKAgSHwoXbWlzc19hY2NlbGVyYXRvcl9zdHJlYW0YBSABKAgSDQoF" + "c3RlcHMYAyADKAMSPwoMaWRfdG9fc3RyaW5nGAQgAygLMikudGVuc29yYm9h" + "cmQuUHJvZmlsZVByb3RvLklkVG9TdHJpbmdFbnRyeRpGCgpOb2Rlc0VudHJ5" + "EgsKA2tleRgBIAEoAxInCgV2YWx1ZRgCIAEoCzIYLnRlbnNvcmJvYXJkLlBy" + "b2ZpbGVOb2RlOgI4ARoxCg9JZFRvU3RyaW5nRW50cnkSCwoDa2V5GAEgASgD" + "Eg0KBXZhbHVlGAIgASgJOgI4ASKSCAoLUHJvZmlsZU5vZGUSDAoEbmFtZRgB" + "IAEoCRIKCgJvcBgJIAEoCRIKCgJpZBgNIAEoAxI0CgZpbnB1dHMYAiADKAsy" + "JC50ZW5zb3Jib2FyZC5Qcm9maWxlTm9kZS5JbnB1dHNFbnRyeRI/CgxpbnB1" + "dF9zaGFwZXMYECADKAsyKS50ZW5zb3Jib2FyZC5Qcm9maWxlTm9kZS5JbnB1" + "dFNoYXBlc0VudHJ5EjYKB291dHB1dHMYAyADKAsyJS50ZW5zb3Jib2FyZC5Q" + "cm9maWxlTm9kZS5PdXRwdXRzRW50cnkSQQoNb3V0cHV0X3NoYXBlcxgPIAMo" + "CzIqLnRlbnNvcmJvYXJkLlByb2ZpbGVOb2RlLk91dHB1dFNoYXBlc0VudHJ5" + "EkYKEHNyY19vdXRwdXRfaW5kZXgYDiADKAsyLC50ZW5zb3Jib2FyZC5Qcm9m" + "aWxlTm9kZS5TcmNPdXRwdXRJbmRleEVudHJ5Eg0KBXNoYXBlGAQgAygDEhAK" + "CG9wX3R5cGVzGAUgAygJEhgKEGNhbm9uaWNhbF9kZXZpY2UYBiABKAkSEwoL" + "aG9zdF9kZXZpY2UYByABKAkSEQoJZmxvYXRfb3BzGAggASgDEiMKBXRyYWNl" + "GAogASgLMhQudGVuc29yYm9hcmQuQ29kZURlZhIyCgVhdHRycxgLIAMoCzIj" + "LnRlbnNvcmJvYXJkLlByb2ZpbGVOb2RlLkF0dHJzRW50cnkSMgoFZXhlY3MY" + "DCADKAsyIy50ZW5zb3Jib2FyZC5Qcm9maWxlTm9kZS5FeGVjc0VudHJ5Gi0K" + "C0lucHV0c0VudHJ5EgsKA2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoAzoCOAEa" + "RgoQSW5wdXRTaGFwZXNFbnRyeRILCgNrZXkYASABKAUSIQoFdmFsdWUYAiAB" + "KAsyEi50ZW5zb3Jib2FyZC5UdXBsZToCOAEaLgoMT3V0cHV0c0VudHJ5EgsK" + "A2tleRgBIAEoBRINCgV2YWx1ZRgCIAEoAzoCOAEaRwoRT3V0cHV0U2hhcGVz" + "RW50cnkSCwoDa2V5GAEgASgFEiEKBXZhbHVlGAIgASgLMhIudGVuc29yYm9h" + "cmQuVHVwbGU6AjgBGjUKE1NyY091dHB1dEluZGV4RW50cnkSCwoDa2V5GAEg" + "ASgDEg0KBXZhbHVlGAIgASgFOgI4ARpECgpBdHRyc0VudHJ5EgsKA2tleRgB" + "IAEoCRIlCgV2YWx1ZRgCIAEoCzIWLnRlbnNvcmJvYXJkLkF0dHJWYWx1ZToC" + "OAEaRgoKRXhlY3NFbnRyeRILCgNrZXkYASABKAMSJwoFdmFsdWUYAiABKAsy" + "GC50ZW5zb3Jib2FyZC5FeGVjUHJvZmlsZToCOAEi5wMKC0V4ZWNQcm9maWxl" + "EhEKCXJ1bl9jb3VudBgBIAEoAxIYChBhbGxfc3RhcnRfbWljcm9zGAIgASgD" + "EhkKEWxhdGVzdF9lbmRfbWljcm9zGAMgASgDEkkKEWFjY2VsZXJhdG9yX2V4" + "ZWNzGAQgAygLMi4udGVuc29yYm9hcmQuRXhlY1Byb2ZpbGUuQWNjZWxlcmF0" + "b3JFeGVjc0VudHJ5EjkKCWNwdV9leGVjcxgFIAMoCzImLnRlbnNvcmJvYXJk" + "LkV4ZWNQcm9maWxlLkNwdUV4ZWNzRW50cnkSLQoMbWVtb3J5X2V4ZWNzGAcg" + "AygLMhcudGVuc29yYm9hcmQuRXhlY01lbW9yeRIyCgthbGxvY2F0aW9ucxgL" + "IAMoCzIdLnRlbnNvcmJvYXJkLkFsbG9jYXRpb25SZWNvcmQSDwoHZGV2aWNl" + "cxgGIAMoCRpOChVBY2NlbGVyYXRvckV4ZWNzRW50cnkSCwoDa2V5GAEgASgJ" + "EiQKBXZhbHVlGAIgASgLMhUudGVuc29yYm9hcmQuRXhlY1RpbWU6AjgBGkYK" + "DUNwdUV4ZWNzRW50cnkSCwoDa2V5GAEgASgJEiQKBXZhbHVlGAIgASgLMhUu" + "dGVuc29yYm9hcmQuRXhlY1RpbWU6AjgBIi0KCEV4ZWNUaW1lEiEKBXRpbWVz" + "GAEgAygLMhIudGVuc29yYm9hcmQuVHVwbGUiqAMKCkV4ZWNNZW1vcnkSFQoN" + "bWVtb3J5X21pY3JvcxgBIAEoAxIXCg9ob3N0X3RlbXBfYnl0ZXMYAiABKAMS" + "HQoVaG9zdF9wZXJzaXN0ZW50X2J5dGVzGAMgASgDEh4KFmFjY2VsZXJhdG9y" + "X3RlbXBfYnl0ZXMYBCABKAMSJAocYWNjZWxlcmF0b3JfcGVyc2lzdGVudF9i" + "eXRlcxgFIAEoAxIXCg9yZXF1ZXN0ZWRfYnl0ZXMYBiABKAMSEgoKcGVha19i" + "eXRlcxgHIAEoAxIWCg5yZXNpZHVhbF9ieXRlcxgIIAEoAxIUCgxvdXRwdXRf" + "Ynl0ZXMYCSABKAMSHgoWYWxsb2NhdG9yX2J5dGVzX2luX3VzZRgKIAEoAxJA" + "Cg1vdXRwdXRfbWVtb3J5GAsgAygLMikudGVuc29yYm9hcmQuRXhlY01lbW9y" + "eS5PdXRwdXRNZW1vcnlFbnRyeRpIChFPdXRwdXRNZW1vcnlFbnRyeRILCgNr" + "ZXkYASABKAUSIgoFdmFsdWUYAiABKAsyEy50ZW5zb3Jib2FyZC5NZW1vcnk6" + "AjgBIh0KBVR1cGxlEhQKDGludDY0X3ZhbHVlcxgBIAMoAyIkCgZNZW1vcnkS" + "DQoFYnl0ZXMYASABKAMSCwoDcHRyGAIgASgEQlJaUGdpdGh1Yi5jb20vdGVu" + "c29yZmxvdy90ZW5zb3JmbG93L3RlbnNvcmZsb3cvZ28vY29yZS9wcm9maWxl" + "ci90ZnByb2ZfbG9nX2dvX3Byb3RvYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[2]
			{
				AttrValueReflection.Descriptor,
				StepStatsReflection.Descriptor
			}, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[10]
			{
				new GeneratedClrTypeInfo(typeof(CodeDef), (MessageParser)(object)CodeDef.Parser, new string[1] { "Traces" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(CodeDef.Types.Trace), (MessageParser)(object)CodeDef.Types.Trace.Parser, new string[8] { "File", "FileId", "Lineno", "Function", "FunctionId", "Line", "LineId", "FuncStartLine" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
				}),
				new GeneratedClrTypeInfo(typeof(OpLogEntry), (MessageParser)(object)OpLogEntry.Parser, new string[4] { "Name", "FloatOps", "Types_", "CodeDef" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(OpLogProto), (MessageParser)(object)OpLogProto.Parser, new string[2] { "LogEntries", "IdToString" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(ProfileProto), (MessageParser)(object)ProfileProto.Parser, new string[5] { "Nodes", "HasTrace", "MissAcceleratorStream", "Steps", "IdToString" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]),
				new GeneratedClrTypeInfo(typeof(ProfileNode), (MessageParser)(object)ProfileNode.Parser, new string[16]
				{
					"Name", "Op", "Id", "Inputs", "InputShapes", "Outputs", "OutputShapes", "SrcOutputIndex", "Shape", "OpTypes",
					"CanonicalDevice", "HostDevice", "FloatOps", "Trace", "Attrs", "Execs"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[7]),
				new GeneratedClrTypeInfo(typeof(ExecProfile), (MessageParser)(object)ExecProfile.Parser, new string[8] { "RunCount", "AllStartMicros", "LatestEndMicros", "AcceleratorExecs", "CpuExecs", "MemoryExecs", "Allocations", "Devices" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]),
				new GeneratedClrTypeInfo(typeof(ExecTime), (MessageParser)(object)ExecTime.Parser, new string[1] { "Times" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(ExecMemory), (MessageParser)(object)ExecMemory.Parser, new string[11]
				{
					"MemoryMicros", "HostTempBytes", "HostPersistentBytes", "AcceleratorTempBytes", "AcceleratorPersistentBytes", "RequestedBytes", "PeakBytes", "ResidualBytes", "OutputBytes", "AllocatorBytesInUse",
					"OutputMemory"
				}, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]),
				new GeneratedClrTypeInfo(typeof(Tuple), (MessageParser)(object)Tuple.Parser, new string[1] { "Int64Values" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(Memory), (MessageParser)(object)Memory.Parser, new string[2] { "Bytes", "Ptr" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class CodeDef : IMessage<CodeDef>, IMessage, IEquatable<CodeDef>, IDeepCloneable<CodeDef>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class Trace : IMessage<Trace>, IMessage, IEquatable<Trace>, IDeepCloneable<Trace>
			{
				private static readonly MessageParser<Trace> _parser = new MessageParser<Trace>((Func<Trace>)(() => new Trace()));

				private UnknownFieldSet _unknownFields;

				public const int FileFieldNumber = 1;

				private string file_ = "";

				public const int FileIdFieldNumber = 6;

				private long fileId_;

				public const int LinenoFieldNumber = 2;

				private int lineno_;

				public const int FunctionFieldNumber = 3;

				private string function_ = "";

				public const int FunctionIdFieldNumber = 7;

				private long functionId_;

				public const int LineFieldNumber = 4;

				private string line_ = "";

				public const int LineIdFieldNumber = 8;

				private long lineId_;

				public const int FuncStartLineFieldNumber = 5;

				private int funcStartLine_;

				[DebuggerNonUserCode]
				public static MessageParser<Trace> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => CodeDef.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[Obsolete]
				[DebuggerNonUserCode]
				public string File
				{
					get
					{
						return file_;
					}
					set
					{
						file_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public long FileId
				{
					get
					{
						return fileId_;
					}
					set
					{
						fileId_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int Lineno
				{
					get
					{
						return lineno_;
					}
					set
					{
						lineno_ = value;
					}
				}

				[Obsolete]
				[DebuggerNonUserCode]
				public string Function
				{
					get
					{
						return function_;
					}
					set
					{
						function_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public long FunctionId
				{
					get
					{
						return functionId_;
					}
					set
					{
						functionId_ = value;
					}
				}

				[Obsolete]
				[DebuggerNonUserCode]
				public string Line
				{
					get
					{
						return line_;
					}
					set
					{
						line_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
					}
				}

				[DebuggerNonUserCode]
				public long LineId
				{
					get
					{
						return lineId_;
					}
					set
					{
						lineId_ = value;
					}
				}

				[DebuggerNonUserCode]
				public int FuncStartLine
				{
					get
					{
						return funcStartLine_;
					}
					set
					{
						funcStartLine_ = value;
					}
				}

				[DebuggerNonUserCode]
				public Trace()
				{
				}

				[DebuggerNonUserCode]
				public Trace(Trace other)
					: this()
				{
					file_ = other.file_;
					fileId_ = other.fileId_;
					lineno_ = other.lineno_;
					function_ = other.function_;
					functionId_ = other.functionId_;
					line_ = other.line_;
					lineId_ = other.lineId_;
					funcStartLine_ = other.funcStartLine_;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public Trace Clone()
				{
					return new Trace(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as Trace);
				}

				[DebuggerNonUserCode]
				public bool Equals(Trace other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (File != other.File)
					{
						return false;
					}
					if (FileId != other.FileId)
					{
						return false;
					}
					if (Lineno != other.Lineno)
					{
						return false;
					}
					if (Function != other.Function)
					{
						return false;
					}
					if (FunctionId != other.FunctionId)
					{
						return false;
					}
					if (Line != other.Line)
					{
						return false;
					}
					if (LineId != other.LineId)
					{
						return false;
					}
					if (FuncStartLine != other.FuncStartLine)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					if (File.Length != 0)
					{
						num ^= File.GetHashCode();
					}
					if (FileId != 0L)
					{
						num ^= FileId.GetHashCode();
					}
					if (Lineno != 0)
					{
						num ^= Lineno.GetHashCode();
					}
					if (Function.Length != 0)
					{
						num ^= Function.GetHashCode();
					}
					if (FunctionId != 0L)
					{
						num ^= FunctionId.GetHashCode();
					}
					if (Line.Length != 0)
					{
						num ^= Line.GetHashCode();
					}
					if (LineId != 0L)
					{
						num ^= LineId.GetHashCode();
					}
					if (FuncStartLine != 0)
					{
						num ^= FuncStartLine.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					if (File.Length != 0)
					{
						output.WriteRawTag((byte)10);
						output.WriteString(File);
					}
					if (Lineno != 0)
					{
						output.WriteRawTag((byte)16);
						output.WriteInt32(Lineno);
					}
					if (Function.Length != 0)
					{
						output.WriteRawTag((byte)26);
						output.WriteString(Function);
					}
					if (Line.Length != 0)
					{
						output.WriteRawTag((byte)34);
						output.WriteString(Line);
					}
					if (FuncStartLine != 0)
					{
						output.WriteRawTag((byte)40);
						output.WriteInt32(FuncStartLine);
					}
					if (FileId != 0L)
					{
						output.WriteRawTag((byte)48);
						output.WriteInt64(FileId);
					}
					if (FunctionId != 0L)
					{
						output.WriteRawTag((byte)56);
						output.WriteInt64(FunctionId);
					}
					if (LineId != 0L)
					{
						output.WriteRawTag((byte)64);
						output.WriteInt64(LineId);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					if (File.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(File);
					}
					if (FileId != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(FileId);
					}
					if (Lineno != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(Lineno);
					}
					if (Function.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Function);
					}
					if (FunctionId != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(FunctionId);
					}
					if (Line.Length != 0)
					{
						num += 1 + CodedOutputStream.ComputeStringSize(Line);
					}
					if (LineId != 0L)
					{
						num += 1 + CodedOutputStream.ComputeInt64Size(LineId);
					}
					if (FuncStartLine != 0)
					{
						num += 1 + CodedOutputStream.ComputeInt32Size(FuncStartLine);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(Trace other)
				{
					if (other != null)
					{
						if (other.File.Length != 0)
						{
							File = other.File;
						}
						if (other.FileId != 0L)
						{
							FileId = other.FileId;
						}
						if (other.Lineno != 0)
						{
							Lineno = other.Lineno;
						}
						if (other.Function.Length != 0)
						{
							Function = other.Function;
						}
						if (other.FunctionId != 0L)
						{
							FunctionId = other.FunctionId;
						}
						if (other.Line.Length != 0)
						{
							Line = other.Line;
						}
						if (other.LineId != 0L)
						{
							LineId = other.LineId;
						}
						if (other.FuncStartLine != 0)
						{
							FuncStartLine = other.FuncStartLine;
						}
						_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
					}
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							File = input.ReadString();
							break;
						case 16u:
							Lineno = input.ReadInt32();
							break;
						case 26u:
							Function = input.ReadString();
							break;
						case 34u:
							Line = input.ReadString();
							break;
						case 40u:
							FuncStartLine = input.ReadInt32();
							break;
						case 48u:
							FileId = input.ReadInt64();
							break;
						case 56u:
							FunctionId = input.ReadInt64();
							break;
						case 64u:
							LineId = input.ReadInt64();
							break;
						}
					}
				}
			}
		}

		private static readonly MessageParser<CodeDef> _parser = new MessageParser<CodeDef>((Func<CodeDef>)(() => new CodeDef()));

		private UnknownFieldSet _unknownFields;

		public const int TracesFieldNumber = 1;

		private static readonly FieldCodec<Types.Trace> _repeated_traces_codec = FieldCodec.ForMessage<Types.Trace>(10u, Types.Trace.Parser);

		private readonly RepeatedField<Types.Trace> traces_ = new RepeatedField<Types.Trace>();

		[DebuggerNonUserCode]
		public static MessageParser<CodeDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<Types.Trace> Traces => traces_;

		[DebuggerNonUserCode]
		public CodeDef()
		{
		}

		[DebuggerNonUserCode]
		public CodeDef(CodeDef other)
			: this()
		{
			traces_ = other.traces_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public CodeDef Clone()
		{
			return new CodeDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as CodeDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(CodeDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!traces_.Equals(other.traces_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)traces_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			traces_.WriteTo(output, _repeated_traces_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += traces_.CalculateSize(_repeated_traces_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodeDef other)
		{
			if (other != null)
			{
				traces_.Add((IEnumerable<Types.Trace>)other.traces_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					traces_.AddEntriesFrom(input, _repeated_traces_codec);
				}
			}
		}
	}
	public sealed class OpLogEntry : IMessage<OpLogEntry>, IMessage, IEquatable<OpLogEntry>, IDeepCloneable<OpLogEntry>
	{
		private static readonly MessageParser<OpLogEntry> _parser = new MessageParser<OpLogEntry>((Func<OpLogEntry>)(() => new OpLogEntry()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int FloatOpsFieldNumber = 2;

		private long floatOps_;

		public const int Types_FieldNumber = 3;

		private static readonly FieldCodec<string> _repeated_types_codec = FieldCodec.ForString(26u);

		private readonly RepeatedField<string> types_ = new RepeatedField<string>();

		public const int CodeDefFieldNumber = 4;

		private CodeDef codeDef_;

		[DebuggerNonUserCode]
		public static MessageParser<OpLogEntry> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long FloatOps
		{
			get
			{
				return floatOps_;
			}
			set
			{
				floatOps_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<string> Types_ => types_;

		[DebuggerNonUserCode]
		public CodeDef CodeDef
		{
			get
			{
				return codeDef_;
			}
			set
			{
				codeDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public OpLogEntry()
		{
		}

		[DebuggerNonUserCode]
		public OpLogEntry(OpLogEntry other)
			: this()
		{
			name_ = other.name_;
			floatOps_ = other.floatOps_;
			types_ = other.types_.Clone();
			codeDef_ = ((other.codeDef_ != null) ? other.codeDef_.Clone() : null);
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public OpLogEntry Clone()
		{
			return new OpLogEntry(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as OpLogEntry);
		}

		[DebuggerNonUserCode]
		public bool Equals(OpLogEntry other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (FloatOps != other.FloatOps)
			{
				return false;
			}
			if (!types_.Equals(other.types_))
			{
				return false;
			}
			if (!object.Equals(CodeDef, other.CodeDef))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (FloatOps != 0L)
			{
				num ^= FloatOps.GetHashCode();
			}
			num ^= ((object)types_).GetHashCode();
			if (codeDef_ != null)
			{
				num ^= CodeDef.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (FloatOps != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(FloatOps);
			}
			types_.WriteTo(output, _repeated_types_codec);
			if (codeDef_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)CodeDef);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (FloatOps != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(FloatOps);
			}
			num += types_.CalculateSize(_repeated_types_codec);
			if (codeDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)CodeDef);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(OpLogEntry other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.FloatOps != 0L)
			{
				FloatOps = other.FloatOps;
			}
			types_.Add((IEnumerable<string>)other.types_);
			if (other.codeDef_ != null)
			{
				if (codeDef_ == null)
				{
					CodeDef = new CodeDef();
				}
				CodeDef.MergeFrom(other.CodeDef);
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 16u:
					FloatOps = input.ReadInt64();
					break;
				case 26u:
					types_.AddEntriesFrom(input, _repeated_types_codec);
					break;
				case 34u:
					if (codeDef_ == null)
					{
						CodeDef = new CodeDef();
					}
					input.ReadMessage((IMessage)(object)CodeDef);
					break;
				}
			}
		}
	}
	public sealed class OpLogProto : IMessage<OpLogProto>, IMessage, IEquatable<OpLogProto>, IDeepCloneable<OpLogProto>
	{
		private static readonly MessageParser<OpLogProto> _parser = new MessageParser<OpLogProto>((Func<OpLogProto>)(() => new OpLogProto()));

		private UnknownFieldSet _unknownFields;

		public const int LogEntriesFieldNumber = 1;

		private static readonly FieldCodec<OpLogEntry> _repeated_logEntries_codec = FieldCodec.ForMessage<OpLogEntry>(10u, OpLogEntry.Parser);

		private readonly RepeatedField<OpLogEntry> logEntries_ = new RepeatedField<OpLogEntry>();

		public const int IdToStringFieldNumber = 2;

		private static readonly Codec<long, string> _map_idToString_codec = new Codec<long, string>(FieldCodec.ForInt64(8u, 0L), FieldCodec.ForString(18u, ""), 18u);

		private readonly MapField<long, string> idToString_ = new MapField<long, string>();

		[DebuggerNonUserCode]
		public static MessageParser<OpLogProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[2];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<OpLogEntry> LogEntries => logEntries_;

		[DebuggerNonUserCode]
		public MapField<long, string> IdToString => idToString_;

		[DebuggerNonUserCode]
		public OpLogProto()
		{
		}

		[DebuggerNonUserCode]
		public OpLogProto(OpLogProto other)
			: this()
		{
			logEntries_ = other.logEntries_.Clone();
			idToString_ = other.idToString_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public OpLogProto Clone()
		{
			return new OpLogProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as OpLogProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(OpLogProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!logEntries_.Equals(other.logEntries_))
			{
				return false;
			}
			if (!IdToString.Equals(other.IdToString))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)logEntries_).GetHashCode();
			num ^= ((object)IdToString).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			logEntries_.WriteTo(output, _repeated_logEntries_codec);
			idToString_.WriteTo(output, _map_idToString_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += logEntries_.CalculateSize(_repeated_logEntries_codec);
			num += idToString_.CalculateSize(_map_idToString_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(OpLogProto other)
		{
			if (other != null)
			{
				logEntries_.Add((IEnumerable<OpLogEntry>)other.logEntries_);
				idToString_.Add((IDictionary<long, string>)other.idToString_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					logEntries_.AddEntriesFrom(input, _repeated_logEntries_codec);
					break;
				case 18u:
					idToString_.AddEntriesFrom(input, _map_idToString_codec);
					break;
				}
			}
		}
	}
	public sealed class ProfileProto : IMessage<ProfileProto>, IMessage, IEquatable<ProfileProto>, IDeepCloneable<ProfileProto>
	{
		private static readonly MessageParser<ProfileProto> _parser = new MessageParser<ProfileProto>((Func<ProfileProto>)(() => new ProfileProto()));

		private UnknownFieldSet _unknownFields;

		public const int NodesFieldNumber = 1;

		private static readonly Codec<long, ProfileNode> _map_nodes_codec = new Codec<long, ProfileNode>(FieldCodec.ForInt64(8u, 0L), FieldCodec.ForMessage<ProfileNode>(18u, ProfileNode.Parser), 10u);

		private readonly MapField<long, ProfileNode> nodes_ = new MapField<long, ProfileNode>();

		public const int HasTraceFieldNumber = 2;

		private bool hasTrace_;

		public const int MissAcceleratorStreamFieldNumber = 5;

		private bool missAcceleratorStream_;

		public const int StepsFieldNumber = 3;

		private static readonly FieldCodec<long> _repeated_steps_codec = FieldCodec.ForInt64(26u);

		private readonly RepeatedField<long> steps_ = new RepeatedField<long>();

		public const int IdToStringFieldNumber = 4;

		private static readonly Codec<long, string> _map_idToString_codec = new Codec<long, string>(FieldCodec.ForInt64(8u, 0L), FieldCodec.ForString(18u, ""), 34u);

		private readonly MapField<long, string> idToString_ = new MapField<long, string>();

		[DebuggerNonUserCode]
		public static MessageParser<ProfileProto> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[3];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public MapField<long, ProfileNode> Nodes => nodes_;

		[DebuggerNonUserCode]
		public bool HasTrace
		{
			get
			{
				return hasTrace_;
			}
			set
			{
				hasTrace_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool MissAcceleratorStream
		{
			get
			{
				return missAcceleratorStream_;
			}
			set
			{
				missAcceleratorStream_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<long> Steps => steps_;

		[DebuggerNonUserCode]
		public MapField<long, string> IdToString => idToString_;

		[DebuggerNonUserCode]
		public ProfileProto()
		{
		}

		[DebuggerNonUserCode]
		public ProfileProto(ProfileProto other)
			: this()
		{
			nodes_ = other.nodes_.Clone();
			hasTrace_ = other.hasTrace_;
			missAcceleratorStream_ = other.missAcceleratorStream_;
			steps_ = other.steps_.Clone();
			idToString_ = other.idToString_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ProfileProto Clone()
		{
			return new ProfileProto(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ProfileProto);
		}

		[DebuggerNonUserCode]
		public bool Equals(ProfileProto other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!Nodes.Equals(other.Nodes))
			{
				return false;
			}
			if (HasTrace != other.HasTrace)
			{
				return false;
			}
			if (MissAcceleratorStream != other.MissAcceleratorStream)
			{
				return false;
			}
			if (!steps_.Equals(other.steps_))
			{
				return false;
			}
			if (!IdToString.Equals(other.IdToString))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)Nodes).GetHashCode();
			if (HasTrace)
			{
				num ^= HasTrace.GetHashCode();
			}
			if (MissAcceleratorStream)
			{
				num ^= MissAcceleratorStream.GetHashCode();
			}
			num ^= ((object)steps_).GetHashCode();
			num ^= ((object)IdToString).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			nodes_.WriteTo(output, _map_nodes_codec);
			if (HasTrace)
			{
				output.WriteRawTag((byte)16);
				output.WriteBool(HasTrace);
			}
			steps_.WriteTo(output, _repeated_steps_codec);
			idToString_.WriteTo(output, _map_idToString_codec);
			if (MissAcceleratorStream)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(MissAcceleratorStream);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += nodes_.CalculateSize(_map_nodes_codec);
			if (HasTrace)
			{
				num += 2;
			}
			if (MissAcceleratorStream)
			{
				num += 2;
			}
			num += steps_.CalculateSize(_repeated_steps_codec);
			num += idToString_.CalculateSize(_map_idToString_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ProfileProto other)
		{
			if (other != null)
			{
				nodes_.Add((IDictionary<long, ProfileNode>)other.nodes_);
				if (other.HasTrace)
				{
					HasTrace = other.HasTrace;
				}
				if (other.MissAcceleratorStream)
				{
					MissAcceleratorStream = other.MissAcceleratorStream;
				}
				steps_.Add((IEnumerable<long>)other.steps_);
				idToString_.Add((IDictionary<long, string>)other.idToString_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					nodes_.AddEntriesFrom(input, _map_nodes_codec);
					break;
				case 16u:
					HasTrace = input.ReadBool();
					break;
				case 24u:
				case 26u:
					steps_.AddEntriesFrom(input, _repeated_steps_codec);
					break;
				case 34u:
					idToString_.AddEntriesFrom(input, _map_idToString_codec);
					break;
				case 40u:
					MissAcceleratorStream = input.ReadBool();
					break;
				}
			}
		}
	}
	public sealed class ProfileNode : IMessage<ProfileNode>, IMessage, IEquatable<ProfileNode>, IDeepCloneable<ProfileNode>
	{
		private static readonly MessageParser<ProfileNode> _parser = new MessageParser<ProfileNode>((Func<ProfileNode>)(() => new ProfileNode()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int OpFieldNumber = 9;

		private string op_ = "";

		public const int IdFieldNumber = 13;

		private long id_;

		public const int InputsFieldNumber = 2;

		private static readonly Codec<int, long> _map_inputs_codec = new Codec<int, long>(FieldCodec.ForInt32(8u, 0), FieldCodec.ForInt64(16u, 0L), 18u);

		private readonly MapField<int, long> inputs_ = new MapField<int, long>();

		public const int InputShapesFieldNumber = 16;

		private static readonly Codec<int, Tuple> _map_inputShapes_codec = new Codec<int, Tuple>(FieldCodec.ForInt32(8u, 0), FieldCodec.ForMessage<Tuple>(18u, Tuple.Parser), 130u);

		private readonly MapField<int, Tuple> inputShapes_ = new MapField<int, Tuple>();

		public const int OutputsFieldNumber = 3;

		private static readonly Codec<int, long> _map_outputs_codec = new Codec<int, long>(FieldCodec.ForInt32(8u, 0), FieldCodec.ForInt64(16u, 0L), 26u);

		private readonly MapField<int, long> outputs_ = new MapField<int, long>();

		public const int OutputShapesFieldNumber = 15;

		private static readonly Codec<int, Tuple> _map_outputShapes_codec = new Codec<int, Tuple>(FieldCodec.ForInt32(8u, 0), FieldCodec.ForMessage<Tuple>(18u, Tuple.Parser), 122u);

		private readonly MapField<int, Tuple> outputShapes_ = new MapField<int, Tuple>();

		public const int SrcOutputIndexFieldNumber = 14;

		private static readonly Codec<long, int> _map_srcOutputIndex_codec = new Codec<long, int>(FieldCodec.ForInt64(8u, 0L), FieldCodec.ForInt32(16u, 0), 114u);

		private readonly MapField<long, int> srcOutputIndex_ = new MapField<long, int>();

		public const int ShapeFieldNumber = 4;

		private static readonly FieldCodec<long> _repeated_shape_codec = FieldCodec.ForInt64(34u);

		private readonly RepeatedField<long> shape_ = new RepeatedField<long>();

		public const int OpTypesFieldNumber = 5;

		private static readonly FieldCodec<string> _repeated_opTypes_codec = FieldCodec.ForString(42u);

		private readonly RepeatedField<string> opTypes_ = new RepeatedField<string>();

		public const int CanonicalDeviceFieldNumber = 6;

		private string canonicalDevice_ = "";

		public const int HostDeviceFieldNumber = 7;

		private string hostDevice_ = "";

		public const int FloatOpsFieldNumber = 8;

		private long floatOps_;

		public const int TraceFieldNumber = 10;

		private CodeDef trace_;

		public const int AttrsFieldNumber = 11;

		private static readonly Codec<string, AttrValue> _map_attrs_codec = new Codec<string, AttrValue>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<AttrValue>(18u, AttrValue.Parser), 90u);

		private readonly MapField<string, AttrValue> attrs_ = new MapField<string, AttrValue>();

		public const int ExecsFieldNumber = 12;

		private static readonly Codec<long, ExecProfile> _map_execs_codec = new Codec<long, ExecProfile>(FieldCodec.ForInt64(8u, 0L), FieldCodec.ForMessage<ExecProfile>(18u, ExecProfile.Parser), 98u);

		private readonly MapField<long, ExecProfile> execs_ = new MapField<long, ExecProfile>();

		[DebuggerNonUserCode]
		public static MessageParser<ProfileNode> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[4];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string Op
		{
			get
			{
				return op_;
			}
			set
			{
				op_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long Id
		{
			get
			{
				return id_;
			}
			set
			{
				id_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MapField<int, long> Inputs => inputs_;

		[DebuggerNonUserCode]
		public MapField<int, Tuple> InputShapes => inputShapes_;

		[DebuggerNonUserCode]
		public MapField<int, long> Outputs => outputs_;

		[DebuggerNonUserCode]
		public MapField<int, Tuple> OutputShapes => outputShapes_;

		[DebuggerNonUserCode]
		public MapField<long, int> SrcOutputIndex => srcOutputIndex_;

		[DebuggerNonUserCode]
		public RepeatedField<long> Shape => shape_;

		[DebuggerNonUserCode]
		public RepeatedField<string> OpTypes => opTypes_;

		[DebuggerNonUserCode]
		public string CanonicalDevice
		{
			get
			{
				return canonicalDevice_;
			}
			set
			{
				canonicalDevice_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string HostDevice
		{
			get
			{
				return hostDevice_;
			}
			set
			{
				hostDevice_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public long FloatOps
		{
			get
			{
				return floatOps_;
			}
			set
			{
				floatOps_ = value;
			}
		}

		[DebuggerNonUserCode]
		public CodeDef Trace
		{
			get
			{
				return trace_;
			}
			set
			{
				trace_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, AttrValue> Attrs => attrs_;

		[DebuggerNonUserCode]
		public MapField<long, ExecProfile> Execs => execs_;

		[DebuggerNonUserCode]
		public ProfileNode()
		{
		}

		[DebuggerNonUserCode]
		public ProfileNode(ProfileNode other)
			: this()
		{
			name_ = other.name_;
			op_ = other.op_;
			id_ = other.id_;
			inputs_ = other.inputs_.Clone();
			inputShapes_ = other.inputShapes_.Clone();
			outputs_ = other.outputs_.Clone();
			outputShapes_ = other.outputShapes_.Clone();
			srcOutputIndex_ = other.srcOutputIndex_.Clone();
			shape_ = other.shape_.Clone();
			opTypes_ = other.opTypes_.Clone();
			canonicalDevice_ = other.canonicalDevice_;
			hostDevice_ = other.hostDevice_;
			floatOps_ = other.floatOps_;
			trace_ = ((other.trace_ != null) ? other.trace_.Clone() : null);
			attrs_ = other.attrs_.Clone();
			execs_ = other.execs_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ProfileNode Clone()
		{
			return new ProfileNode(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ProfileNode);
		}

		[DebuggerNonUserCode]
		public bool Equals(ProfileNode other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (Op != other.Op)
			{
				return false;
			}
			if (Id != other.Id)
			{
				return false;
			}
			if (!Inputs.Equals(other.Inputs))
			{
				return false;
			}
			if (!InputShapes.Equals(other.InputShapes))
			{
				return false;
			}
			if (!Outputs.Equals(other.Outputs))
			{
				return false;
			}
			if (!OutputShapes.Equals(other.OutputShapes))
			{
				return false;
			}
			if (!SrcOutputIndex.Equals(other.SrcOutputIndex))
			{
				return false;
			}
			if (!shape_.Equals(other.shape_))
			{
				return false;
			}
			if (!opTypes_.Equals(other.opTypes_))
			{
				return false;
			}
			if (CanonicalDevice != other.CanonicalDevice)
			{
				return false;
			}
			if (HostDevice != other.HostDevice)
			{
				return false;
			}
			if (FloatOps != other.FloatOps)
			{
				return false;
			}
			if (!object.Equals(Trace, other.Trace))
			{
				return false;
			}
			if (!Attrs.Equals(other.Attrs))
			{
				return false;
			}
			if (!Execs.Equals(other.Execs))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (Op.Length != 0)
			{
				num ^= Op.GetHashCode();
			}
			if (Id != 0L)
			{
				num ^= Id.GetHashCode();
			}
			num ^= ((object)Inputs).GetHashCode();
			num ^= ((object)InputShapes).GetHashCode();
			num ^= ((object)Outputs).GetHashCode();
			num ^= ((object)OutputShapes).GetHashCode();
			num ^= ((object)SrcOutputIndex).GetHashCode();
			num ^= ((object)shape_).GetHashCode();
			num ^= ((object)opTypes_).GetHashCode();
			if (CanonicalDevice.Length != 0)
			{
				num ^= CanonicalDevice.GetHashCode();
			}
			if (HostDevice.Length != 0)
			{
				num ^= HostDevice.GetHashCode();
			}
			if (FloatOps != 0L)
			{
				num ^= FloatOps.GetHashCode();
			}
			if (trace_ != null)
			{
				num ^= Trace.GetHashCode();
			}
			num ^= ((object)Attrs).GetHashCode();
			num ^= ((object)Execs).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			inputs_.WriteTo(output, _map_inputs_codec);
			outputs_.WriteTo(output, _map_outputs_codec);
			shape_.WriteTo(output, _repeated_shape_codec);
			opTypes_.WriteTo(output, _repeated_opTypes_codec);
			if (CanonicalDevice.Length != 0)
			{
				output.WriteRawTag((byte)50);
				output.WriteString(CanonicalDevice);
			}
			if (HostDevice.Length != 0)
			{
				output.WriteRawTag((byte)58);
				output.WriteString(HostDevice);
			}
			if (FloatOps != 0L)
			{
				output.WriteRawTag((byte)64);
				output.WriteInt64(FloatOps);
			}
			if (Op.Length != 0)
			{
				output.WriteRawTag((byte)74);
				output.WriteString(Op);
			}
			if (trace_ != null)
			{
				output.WriteRawTag((byte)82);
				output.WriteMessage((IMessage)(object)Trace);
			}
			attrs_.WriteTo(output, _map_attrs_codec);
			execs_.WriteTo(output, _map_execs_codec);
			if (Id != 0L)
			{
				output.WriteRawTag((byte)104);
				output.WriteInt64(Id);
			}
			srcOutputIndex_.WriteTo(output, _map_srcOutputIndex_codec);
			outputShapes_.WriteTo(output, _map_outputShapes_codec);
			inputShapes_.WriteTo(output, _map_inputShapes_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (Op.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Op);
			}
			if (Id != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Id);
			}
			num += inputs_.CalculateSize(_map_inputs_codec);
			num += inputShapes_.CalculateSize(_map_inputShapes_codec);
			num += outputs_.CalculateSize(_map_outputs_codec);
			num += outputShapes_.CalculateSize(_map_outputShapes_codec);
			num += srcOutputIndex_.CalculateSize(_map_srcOutputIndex_codec);
			num += shape_.CalculateSize(_repeated_shape_codec);
			num += opTypes_.CalculateSize(_repeated_opTypes_codec);
			if (CanonicalDevice.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(CanonicalDevice);
			}
			if (HostDevice.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(HostDevice);
			}
			if (FloatOps != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(FloatOps);
			}
			if (trace_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)Trace);
			}
			num += attrs_.CalculateSize(_map_attrs_codec);
			num += execs_.CalculateSize(_map_execs_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ProfileNode other)
		{
			if (other == null)
			{
				return;
			}
			if (other.Name.Length != 0)
			{
				Name = other.Name;
			}
			if (other.Op.Length != 0)
			{
				Op = other.Op;
			}
			if (other.Id != 0L)
			{
				Id = other.Id;
			}
			inputs_.Add((IDictionary<int, long>)other.inputs_);
			inputShapes_.Add((IDictionary<int, Tuple>)other.inputShapes_);
			outputs_.Add((IDictionary<int, long>)other.outputs_);
			outputShapes_.Add((IDictionary<int, Tuple>)other.outputShapes_);
			srcOutputIndex_.Add((IDictionary<long, int>)other.srcOutputIndex_);
			shape_.Add((IEnumerable<long>)other.shape_);
			opTypes_.Add((IEnumerable<string>)other.opTypes_);
			if (other.CanonicalDevice.Length != 0)
			{
				CanonicalDevice = other.CanonicalDevice;
			}
			if (other.HostDevice.Length != 0)
			{
				HostDevice = other.HostDevice;
			}
			if (other.FloatOps != 0L)
			{
				FloatOps = other.FloatOps;
			}
			if (other.trace_ != null)
			{
				if (trace_ == null)
				{
					Trace = new CodeDef();
				}
				Trace.MergeFrom(other.Trace);
			}
			attrs_.Add((IDictionary<string, AttrValue>)other.attrs_);
			execs_.Add((IDictionary<long, ExecProfile>)other.execs_);
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					inputs_.AddEntriesFrom(input, _map_inputs_codec);
					break;
				case 26u:
					outputs_.AddEntriesFrom(input, _map_outputs_codec);
					break;
				case 32u:
				case 34u:
					shape_.AddEntriesFrom(input, _repeated_shape_codec);
					break;
				case 42u:
					opTypes_.AddEntriesFrom(input, _repeated_opTypes_codec);
					break;
				case 50u:
					CanonicalDevice = input.ReadString();
					break;
				case 58u:
					HostDevice = input.ReadString();
					break;
				case 64u:
					FloatOps = input.ReadInt64();
					break;
				case 74u:
					Op = input.ReadString();
					break;
				case 82u:
					if (trace_ == null)
					{
						Trace = new CodeDef();
					}
					input.ReadMessage((IMessage)(object)Trace);
					break;
				case 90u:
					attrs_.AddEntriesFrom(input, _map_attrs_codec);
					break;
				case 98u:
					execs_.AddEntriesFrom(input, _map_execs_codec);
					break;
				case 104u:
					Id = input.ReadInt64();
					break;
				case 114u:
					srcOutputIndex_.AddEntriesFrom(input, _map_srcOutputIndex_codec);
					break;
				case 122u:
					outputShapes_.AddEntriesFrom(input, _map_outputShapes_codec);
					break;
				case 130u:
					inputShapes_.AddEntriesFrom(input, _map_inputShapes_codec);
					break;
				}
			}
		}
	}
	public sealed class ExecProfile : IMessage<ExecProfile>, IMessage, IEquatable<ExecProfile>, IDeepCloneable<ExecProfile>
	{
		private static readonly MessageParser<ExecProfile> _parser = new MessageParser<ExecProfile>((Func<ExecProfile>)(() => new ExecProfile()));

		private UnknownFieldSet _unknownFields;

		public const int RunCountFieldNumber = 1;

		private long runCount_;

		public const int AllStartMicrosFieldNumber = 2;

		private long allStartMicros_;

		public const int LatestEndMicrosFieldNumber = 3;

		private long latestEndMicros_;

		public const int AcceleratorExecsFieldNumber = 4;

		private static readonly Codec<string, ExecTime> _map_acceleratorExecs_codec = new Codec<string, ExecTime>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<ExecTime>(18u, ExecTime.Parser), 34u);

		private readonly MapField<string, ExecTime> acceleratorExecs_ = new MapField<string, ExecTime>();

		public const int CpuExecsFieldNumber = 5;

		private static readonly Codec<string, ExecTime> _map_cpuExecs_codec = new Codec<string, ExecTime>(FieldCodec.ForString(10u, ""), FieldCodec.ForMessage<ExecTime>(18u, ExecTime.Parser), 42u);

		private readonly MapField<string, ExecTime> cpuExecs_ = new MapField<string, ExecTime>();

		public const int MemoryExecsFieldNumber = 7;

		private static readonly FieldCodec<ExecMemory> _repeated_memoryExecs_codec = FieldCodec.ForMessage<ExecMemory>(58u, ExecMemory.Parser);

		private readonly RepeatedField<ExecMemory> memoryExecs_ = new RepeatedField<ExecMemory>();

		public const int AllocationsFieldNumber = 11;

		private static readonly FieldCodec<AllocationRecord> _repeated_allocations_codec = FieldCodec.ForMessage<AllocationRecord>(90u, AllocationRecord.Parser);

		private readonly RepeatedField<AllocationRecord> allocations_ = new RepeatedField<AllocationRecord>();

		public const int DevicesFieldNumber = 6;

		private static readonly FieldCodec<string> _repeated_devices_codec = FieldCodec.ForString(50u);

		private readonly RepeatedField<string> devices_ = new RepeatedField<string>();

		[DebuggerNonUserCode]
		public static MessageParser<ExecProfile> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[5];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long RunCount
		{
			get
			{
				return runCount_;
			}
			set
			{
				runCount_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllStartMicros
		{
			get
			{
				return allStartMicros_;
			}
			set
			{
				allStartMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long LatestEndMicros
		{
			get
			{
				return latestEndMicros_;
			}
			set
			{
				latestEndMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MapField<string, ExecTime> AcceleratorExecs => acceleratorExecs_;

		[DebuggerNonUserCode]
		public MapField<string, ExecTime> CpuExecs => cpuExecs_;

		[DebuggerNonUserCode]
		public RepeatedField<ExecMemory> MemoryExecs => memoryExecs_;

		[DebuggerNonUserCode]
		public RepeatedField<AllocationRecord> Allocations => allocations_;

		[DebuggerNonUserCode]
		public RepeatedField<string> Devices => devices_;

		[DebuggerNonUserCode]
		public ExecProfile()
		{
		}

		[DebuggerNonUserCode]
		public ExecProfile(ExecProfile other)
			: this()
		{
			runCount_ = other.runCount_;
			allStartMicros_ = other.allStartMicros_;
			latestEndMicros_ = other.latestEndMicros_;
			acceleratorExecs_ = other.acceleratorExecs_.Clone();
			cpuExecs_ = other.cpuExecs_.Clone();
			memoryExecs_ = other.memoryExecs_.Clone();
			allocations_ = other.allocations_.Clone();
			devices_ = other.devices_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ExecProfile Clone()
		{
			return new ExecProfile(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ExecProfile);
		}

		[DebuggerNonUserCode]
		public bool Equals(ExecProfile other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (RunCount != other.RunCount)
			{
				return false;
			}
			if (AllStartMicros != other.AllStartMicros)
			{
				return false;
			}
			if (LatestEndMicros != other.LatestEndMicros)
			{
				return false;
			}
			if (!AcceleratorExecs.Equals(other.AcceleratorExecs))
			{
				return false;
			}
			if (!CpuExecs.Equals(other.CpuExecs))
			{
				return false;
			}
			if (!memoryExecs_.Equals(other.memoryExecs_))
			{
				return false;
			}
			if (!allocations_.Equals(other.allocations_))
			{
				return false;
			}
			if (!devices_.Equals(other.devices_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (RunCount != 0L)
			{
				num ^= RunCount.GetHashCode();
			}
			if (AllStartMicros != 0L)
			{
				num ^= AllStartMicros.GetHashCode();
			}
			if (LatestEndMicros != 0L)
			{
				num ^= LatestEndMicros.GetHashCode();
			}
			num ^= ((object)AcceleratorExecs).GetHashCode();
			num ^= ((object)CpuExecs).GetHashCode();
			num ^= ((object)memoryExecs_).GetHashCode();
			num ^= ((object)allocations_).GetHashCode();
			num ^= ((object)devices_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (RunCount != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(RunCount);
			}
			if (AllStartMicros != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(AllStartMicros);
			}
			if (LatestEndMicros != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(LatestEndMicros);
			}
			acceleratorExecs_.WriteTo(output, _map_acceleratorExecs_codec);
			cpuExecs_.WriteTo(output, _map_cpuExecs_codec);
			devices_.WriteTo(output, _repeated_devices_codec);
			memoryExecs_.WriteTo(output, _repeated_memoryExecs_codec);
			allocations_.WriteTo(output, _repeated_allocations_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (RunCount != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(RunCount);
			}
			if (AllStartMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllStartMicros);
			}
			if (LatestEndMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(LatestEndMicros);
			}
			num += acceleratorExecs_.CalculateSize(_map_acceleratorExecs_codec);
			num += cpuExecs_.CalculateSize(_map_cpuExecs_codec);
			num += memoryExecs_.CalculateSize(_repeated_memoryExecs_codec);
			num += allocations_.CalculateSize(_repeated_allocations_codec);
			num += devices_.CalculateSize(_repeated_devices_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ExecProfile other)
		{
			if (other != null)
			{
				if (other.RunCount != 0L)
				{
					RunCount = other.RunCount;
				}
				if (other.AllStartMicros != 0L)
				{
					AllStartMicros = other.AllStartMicros;
				}
				if (other.LatestEndMicros != 0L)
				{
					LatestEndMicros = other.LatestEndMicros;
				}
				acceleratorExecs_.Add((IDictionary<string, ExecTime>)other.acceleratorExecs_);
				cpuExecs_.Add((IDictionary<string, ExecTime>)other.cpuExecs_);
				memoryExecs_.Add((IEnumerable<ExecMemory>)other.memoryExecs_);
				allocations_.Add((IEnumerable<AllocationRecord>)other.allocations_);
				devices_.Add((IEnumerable<string>)other.devices_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					RunCount = input.ReadInt64();
					break;
				case 16u:
					AllStartMicros = input.ReadInt64();
					break;
				case 24u:
					LatestEndMicros = input.ReadInt64();
					break;
				case 34u:
					acceleratorExecs_.AddEntriesFrom(input, _map_acceleratorExecs_codec);
					break;
				case 42u:
					cpuExecs_.AddEntriesFrom(input, _map_cpuExecs_codec);
					break;
				case 50u:
					devices_.AddEntriesFrom(input, _repeated_devices_codec);
					break;
				case 58u:
					memoryExecs_.AddEntriesFrom(input, _repeated_memoryExecs_codec);
					break;
				case 90u:
					allocations_.AddEntriesFrom(input, _repeated_allocations_codec);
					break;
				}
			}
		}
	}
	public sealed class ExecTime : IMessage<ExecTime>, IMessage, IEquatable<ExecTime>, IDeepCloneable<ExecTime>
	{
		private static readonly MessageParser<ExecTime> _parser = new MessageParser<ExecTime>((Func<ExecTime>)(() => new ExecTime()));

		private UnknownFieldSet _unknownFields;

		public const int TimesFieldNumber = 1;

		private static readonly FieldCodec<Tuple> _repeated_times_codec = FieldCodec.ForMessage<Tuple>(10u, Tuple.Parser);

		private readonly RepeatedField<Tuple> times_ = new RepeatedField<Tuple>();

		[DebuggerNonUserCode]
		public static MessageParser<ExecTime> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[6];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<Tuple> Times => times_;

		[DebuggerNonUserCode]
		public ExecTime()
		{
		}

		[DebuggerNonUserCode]
		public ExecTime(ExecTime other)
			: this()
		{
			times_ = other.times_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ExecTime Clone()
		{
			return new ExecTime(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ExecTime);
		}

		[DebuggerNonUserCode]
		public bool Equals(ExecTime other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!times_.Equals(other.times_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)times_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			times_.WriteTo(output, _repeated_times_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += times_.CalculateSize(_repeated_times_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ExecTime other)
		{
			if (other != null)
			{
				times_.Add((IEnumerable<Tuple>)other.times_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					times_.AddEntriesFrom(input, _repeated_times_codec);
				}
			}
		}
	}
	public sealed class ExecMemory : IMessage<ExecMemory>, IMessage, IEquatable<ExecMemory>, IDeepCloneable<ExecMemory>
	{
		private static readonly MessageParser<ExecMemory> _parser = new MessageParser<ExecMemory>((Func<ExecMemory>)(() => new ExecMemory()));

		private UnknownFieldSet _unknownFields;

		public const int MemoryMicrosFieldNumber = 1;

		private long memoryMicros_;

		public const int HostTempBytesFieldNumber = 2;

		private long hostTempBytes_;

		public const int HostPersistentBytesFieldNumber = 3;

		private long hostPersistentBytes_;

		public const int AcceleratorTempBytesFieldNumber = 4;

		private long acceleratorTempBytes_;

		public const int AcceleratorPersistentBytesFieldNumber = 5;

		private long acceleratorPersistentBytes_;

		public const int RequestedBytesFieldNumber = 6;

		private long requestedBytes_;

		public const int PeakBytesFieldNumber = 7;

		private long peakBytes_;

		public const int ResidualBytesFieldNumber = 8;

		private long residualBytes_;

		public const int OutputBytesFieldNumber = 9;

		private long outputBytes_;

		public const int AllocatorBytesInUseFieldNumber = 10;

		private long allocatorBytesInUse_;

		public const int OutputMemoryFieldNumber = 11;

		private static readonly Codec<int, Memory> _map_outputMemory_codec = new Codec<int, Memory>(FieldCodec.ForInt32(8u, 0), FieldCodec.ForMessage<Memory>(18u, Memory.Parser), 90u);

		private readonly MapField<int, Memory> outputMemory_ = new MapField<int, Memory>();

		[DebuggerNonUserCode]
		public static MessageParser<ExecMemory> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[7];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long MemoryMicros
		{
			get
			{
				return memoryMicros_;
			}
			set
			{
				memoryMicros_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long HostTempBytes
		{
			get
			{
				return hostTempBytes_;
			}
			set
			{
				hostTempBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long HostPersistentBytes
		{
			get
			{
				return hostPersistentBytes_;
			}
			set
			{
				hostPersistentBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AcceleratorTempBytes
		{
			get
			{
				return acceleratorTempBytes_;
			}
			set
			{
				acceleratorTempBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AcceleratorPersistentBytes
		{
			get
			{
				return acceleratorPersistentBytes_;
			}
			set
			{
				acceleratorPersistentBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long RequestedBytes
		{
			get
			{
				return requestedBytes_;
			}
			set
			{
				requestedBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long PeakBytes
		{
			get
			{
				return peakBytes_;
			}
			set
			{
				peakBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long ResidualBytes
		{
			get
			{
				return residualBytes_;
			}
			set
			{
				residualBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long OutputBytes
		{
			get
			{
				return outputBytes_;
			}
			set
			{
				outputBytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public long AllocatorBytesInUse
		{
			get
			{
				return allocatorBytesInUse_;
			}
			set
			{
				allocatorBytesInUse_ = value;
			}
		}

		[DebuggerNonUserCode]
		public MapField<int, Memory> OutputMemory => outputMemory_;

		[DebuggerNonUserCode]
		public ExecMemory()
		{
		}

		[DebuggerNonUserCode]
		public ExecMemory(ExecMemory other)
			: this()
		{
			memoryMicros_ = other.memoryMicros_;
			hostTempBytes_ = other.hostTempBytes_;
			hostPersistentBytes_ = other.hostPersistentBytes_;
			acceleratorTempBytes_ = other.acceleratorTempBytes_;
			acceleratorPersistentBytes_ = other.acceleratorPersistentBytes_;
			requestedBytes_ = other.requestedBytes_;
			peakBytes_ = other.peakBytes_;
			residualBytes_ = other.residualBytes_;
			outputBytes_ = other.outputBytes_;
			allocatorBytesInUse_ = other.allocatorBytesInUse_;
			outputMemory_ = other.outputMemory_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public ExecMemory Clone()
		{
			return new ExecMemory(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as ExecMemory);
		}

		[DebuggerNonUserCode]
		public bool Equals(ExecMemory other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (MemoryMicros != other.MemoryMicros)
			{
				return false;
			}
			if (HostTempBytes != other.HostTempBytes)
			{
				return false;
			}
			if (HostPersistentBytes != other.HostPersistentBytes)
			{
				return false;
			}
			if (AcceleratorTempBytes != other.AcceleratorTempBytes)
			{
				return false;
			}
			if (AcceleratorPersistentBytes != other.AcceleratorPersistentBytes)
			{
				return false;
			}
			if (RequestedBytes != other.RequestedBytes)
			{
				return false;
			}
			if (PeakBytes != other.PeakBytes)
			{
				return false;
			}
			if (ResidualBytes != other.ResidualBytes)
			{
				return false;
			}
			if (OutputBytes != other.OutputBytes)
			{
				return false;
			}
			if (AllocatorBytesInUse != other.AllocatorBytesInUse)
			{
				return false;
			}
			if (!OutputMemory.Equals(other.OutputMemory))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (MemoryMicros != 0L)
			{
				num ^= MemoryMicros.GetHashCode();
			}
			if (HostTempBytes != 0L)
			{
				num ^= HostTempBytes.GetHashCode();
			}
			if (HostPersistentBytes != 0L)
			{
				num ^= HostPersistentBytes.GetHashCode();
			}
			if (AcceleratorTempBytes != 0L)
			{
				num ^= AcceleratorTempBytes.GetHashCode();
			}
			if (AcceleratorPersistentBytes != 0L)
			{
				num ^= AcceleratorPersistentBytes.GetHashCode();
			}
			if (RequestedBytes != 0L)
			{
				num ^= RequestedBytes.GetHashCode();
			}
			if (PeakBytes != 0L)
			{
				num ^= PeakBytes.GetHashCode();
			}
			if (ResidualBytes != 0L)
			{
				num ^= ResidualBytes.GetHashCode();
			}
			if (OutputBytes != 0L)
			{
				num ^= OutputBytes.GetHashCode();
			}
			if (AllocatorBytesInUse != 0L)
			{
				num ^= AllocatorBytesInUse.GetHashCode();
			}
			num ^= ((object)OutputMemory).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (MemoryMicros != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(MemoryMicros);
			}
			if (HostTempBytes != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt64(HostTempBytes);
			}
			if (HostPersistentBytes != 0L)
			{
				output.WriteRawTag((byte)24);
				output.WriteInt64(HostPersistentBytes);
			}
			if (AcceleratorTempBytes != 0L)
			{
				output.WriteRawTag((byte)32);
				output.WriteInt64(AcceleratorTempBytes);
			}
			if (AcceleratorPersistentBytes != 0L)
			{
				output.WriteRawTag((byte)40);
				output.WriteInt64(AcceleratorPersistentBytes);
			}
			if (RequestedBytes != 0L)
			{
				output.WriteRawTag((byte)48);
				output.WriteInt64(RequestedBytes);
			}
			if (PeakBytes != 0L)
			{
				output.WriteRawTag((byte)56);
				output.WriteInt64(PeakBytes);
			}
			if (ResidualBytes != 0L)
			{
				output.WriteRawTag((byte)64);
				output.WriteInt64(ResidualBytes);
			}
			if (OutputBytes != 0L)
			{
				output.WriteRawTag((byte)72);
				output.WriteInt64(OutputBytes);
			}
			if (AllocatorBytesInUse != 0L)
			{
				output.WriteRawTag((byte)80);
				output.WriteInt64(AllocatorBytesInUse);
			}
			outputMemory_.WriteTo(output, _map_outputMemory_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (MemoryMicros != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(MemoryMicros);
			}
			if (HostTempBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(HostTempBytes);
			}
			if (HostPersistentBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(HostPersistentBytes);
			}
			if (AcceleratorTempBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AcceleratorTempBytes);
			}
			if (AcceleratorPersistentBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AcceleratorPersistentBytes);
			}
			if (RequestedBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(RequestedBytes);
			}
			if (PeakBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(PeakBytes);
			}
			if (ResidualBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(ResidualBytes);
			}
			if (OutputBytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(OutputBytes);
			}
			if (AllocatorBytesInUse != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(AllocatorBytesInUse);
			}
			num += outputMemory_.CalculateSize(_map_outputMemory_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(ExecMemory other)
		{
			if (other != null)
			{
				if (other.MemoryMicros != 0L)
				{
					MemoryMicros = other.MemoryMicros;
				}
				if (other.HostTempBytes != 0L)
				{
					HostTempBytes = other.HostTempBytes;
				}
				if (other.HostPersistentBytes != 0L)
				{
					HostPersistentBytes = other.HostPersistentBytes;
				}
				if (other.AcceleratorTempBytes != 0L)
				{
					AcceleratorTempBytes = other.AcceleratorTempBytes;
				}
				if (other.AcceleratorPersistentBytes != 0L)
				{
					AcceleratorPersistentBytes = other.AcceleratorPersistentBytes;
				}
				if (other.RequestedBytes != 0L)
				{
					RequestedBytes = other.RequestedBytes;
				}
				if (other.PeakBytes != 0L)
				{
					PeakBytes = other.PeakBytes;
				}
				if (other.ResidualBytes != 0L)
				{
					ResidualBytes = other.ResidualBytes;
				}
				if (other.OutputBytes != 0L)
				{
					OutputBytes = other.OutputBytes;
				}
				if (other.AllocatorBytesInUse != 0L)
				{
					AllocatorBytesInUse = other.AllocatorBytesInUse;
				}
				outputMemory_.Add((IDictionary<int, Memory>)other.outputMemory_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					MemoryMicros = input.ReadInt64();
					break;
				case 16u:
					HostTempBytes = input.ReadInt64();
					break;
				case 24u:
					HostPersistentBytes = input.ReadInt64();
					break;
				case 32u:
					AcceleratorTempBytes = input.ReadInt64();
					break;
				case 40u:
					AcceleratorPersistentBytes = input.ReadInt64();
					break;
				case 48u:
					RequestedBytes = input.ReadInt64();
					break;
				case 56u:
					PeakBytes = input.ReadInt64();
					break;
				case 64u:
					ResidualBytes = input.ReadInt64();
					break;
				case 72u:
					OutputBytes = input.ReadInt64();
					break;
				case 80u:
					AllocatorBytesInUse = input.ReadInt64();
					break;
				case 90u:
					outputMemory_.AddEntriesFrom(input, _map_outputMemory_codec);
					break;
				}
			}
		}
	}
	public sealed class Tuple : IMessage<Tuple>, IMessage, IEquatable<Tuple>, IDeepCloneable<Tuple>
	{
		private static readonly MessageParser<Tuple> _parser = new MessageParser<Tuple>((Func<Tuple>)(() => new Tuple()));

		private UnknownFieldSet _unknownFields;

		public const int Int64ValuesFieldNumber = 1;

		private static readonly FieldCodec<long> _repeated_int64Values_codec = FieldCodec.ForInt64(10u);

		private readonly RepeatedField<long> int64Values_ = new RepeatedField<long>();

		[DebuggerNonUserCode]
		public static MessageParser<Tuple> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[8];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<long> Int64Values => int64Values_;

		[DebuggerNonUserCode]
		public Tuple()
		{
		}

		[DebuggerNonUserCode]
		public Tuple(Tuple other)
			: this()
		{
			int64Values_ = other.int64Values_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public Tuple Clone()
		{
			return new Tuple(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as Tuple);
		}

		[DebuggerNonUserCode]
		public bool Equals(Tuple other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!int64Values_.Equals(other.int64Values_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)int64Values_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			int64Values_.WriteTo(output, _repeated_int64Values_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += int64Values_.CalculateSize(_repeated_int64Values_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(Tuple other)
		{
			if (other != null)
			{
				int64Values_.Add((IEnumerable<long>)other.int64Values_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 8 && num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					int64Values_.AddEntriesFrom(input, _repeated_int64Values_codec);
				}
			}
		}
	}
	public sealed class Memory : IMessage<Memory>, IMessage, IEquatable<Memory>, IDeepCloneable<Memory>
	{
		private static readonly MessageParser<Memory> _parser = new MessageParser<Memory>((Func<Memory>)(() => new Memory()));

		private UnknownFieldSet _unknownFields;

		public const int BytesFieldNumber = 1;

		private long bytes_;

		public const int PtrFieldNumber = 2;

		private ulong ptr_;

		[DebuggerNonUserCode]
		public static MessageParser<Memory> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TfprofLogReflection.Descriptor.MessageTypes[9];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long Bytes
		{
			get
			{
				return bytes_;
			}
			set
			{
				bytes_ = value;
			}
		}

		[DebuggerNonUserCode]
		public ulong Ptr
		{
			get
			{
				return ptr_;
			}
			set
			{
				ptr_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Memory()
		{
		}

		[DebuggerNonUserCode]
		public Memory(Memory other)
			: this()
		{
			bytes_ = other.bytes_;
			ptr_ = other.ptr_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public Memory Clone()
		{
			return new Memory(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as Memory);
		}

		[DebuggerNonUserCode]
		public bool Equals(Memory other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Bytes != other.Bytes)
			{
				return false;
			}
			if (Ptr != other.Ptr)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Bytes != 0L)
			{
				num ^= Bytes.GetHashCode();
			}
			if (Ptr != 0L)
			{
				num ^= Ptr.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Bytes != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(Bytes);
			}
			if (Ptr != 0L)
			{
				output.WriteRawTag((byte)16);
				output.WriteUInt64(Ptr);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Bytes != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(Bytes);
			}
			if (Ptr != 0L)
			{
				num += 1 + CodedOutputStream.ComputeUInt64Size(Ptr);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(Memory other)
		{
			if (other != null)
			{
				if (other.Bytes != 0L)
				{
					Bytes = other.Bytes;
				}
				if (other.Ptr != 0L)
				{
					Ptr = other.Ptr;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Bytes = input.ReadInt64();
					break;
				case 16u:
					Ptr = input.ReadUInt64();
					break;
				}
			}
		}
	}
	public static class TrackableObjectGraphReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TrackableObjectGraphReflection()
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Expected O, but got Unknown
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Expected O, but got Unknown
			//IL_0237: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Expected O, but got Unknown
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CjV0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdHJhY2thYmxlX29iamVjdF9n" + "cmFwaC5wcm90bxILdGVuc29yYm9hcmQaHmdvb2dsZS9wcm90b2J1Zi93cmFw" + "cGVycy5wcm90byL4BQoUVHJhY2thYmxlT2JqZWN0R3JhcGgSQAoFbm9kZXMY" + "ASADKAsyMS50ZW5zb3Jib2FyZC5UcmFja2FibGVPYmplY3RHcmFwaC5UcmFj" + "a2FibGVPYmplY3QanQUKD1RyYWNrYWJsZU9iamVjdBJTCghjaGlsZHJlbhgB" + "IAMoCzJBLnRlbnNvcmJvYXJkLlRyYWNrYWJsZU9iamVjdEdyYXBoLlRyYWNr" + "YWJsZU9iamVjdC5PYmplY3RSZWZlcmVuY2USVgoKYXR0cmlidXRlcxgCIAMo" + "CzJCLnRlbnNvcmJvYXJkLlRyYWNrYWJsZU9iamVjdEdyYXBoLlRyYWNrYWJs" + "ZU9iamVjdC5TZXJpYWxpemVkVGVuc29yEl8KDnNsb3RfdmFyaWFibGVzGAMg" + "AygLMkcudGVuc29yYm9hcmQuVHJhY2thYmxlT2JqZWN0R3JhcGguVHJhY2th" + "YmxlT2JqZWN0LlNsb3RWYXJpYWJsZVJlZmVyZW5jZRI2ChByZWdpc3RlcmVk" + "X3NhdmVyGAQgASgLMhwudGVuc29yYm9hcmQuUmVnaXN0ZXJlZFNhdmVyEjkK" + "FWhhc19jaGVja3BvaW50X3ZhbHVlcxgFIAEoCzIaLmdvb2dsZS5wcm90b2J1" + "Zi5Cb29sVmFsdWUaNgoPT2JqZWN0UmVmZXJlbmNlEg8KB25vZGVfaWQYASAB" + "KAUSEgoKbG9jYWxfbmFtZRgCIAEoCRpjChBTZXJpYWxpemVkVGVuc29yEgwK" + "BG5hbWUYASABKAkSEQoJZnVsbF9uYW1lGAIgASgJEhYKDmNoZWNrcG9pbnRf" + "a2V5GAMgASgJSgQIBBAFUhBvcHRpb25hbF9yZXN0b3JlGmwKFVNsb3RWYXJp" + "YWJsZVJlZmVyZW5jZRIhChlvcmlnaW5hbF92YXJpYWJsZV9ub2RlX2lkGAEg" + "ASgFEhEKCXNsb3RfbmFtZRgCIAEoCRIdChVzbG90X3ZhcmlhYmxlX25vZGVf" + "aWQYAyABKAUiNAoPUmVnaXN0ZXJlZFNhdmVyEgwKBG5hbWUYASABKAkSEwoL" + "b2JqZWN0X25hbWUYAiABKAlCWlpVZ2l0aHViLmNvbS90ZW5zb3JmbG93L3Rl" + "bnNvcmZsb3cvdGVuc29yZmxvdy9nby9jb3JlL3Byb3RvYnVmL2Zvcl9jb3Jl" + "X3Byb3Rvc19nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[1] { WrappersReflection.Descriptor }, new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(TrackableObjectGraph), (MessageParser)(object)TrackableObjectGraph.Parser, new string[1] { "Nodes" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
				{
					new GeneratedClrTypeInfo(typeof(TrackableObjectGraph.Types.TrackableObject), (MessageParser)(object)TrackableObjectGraph.Types.TrackableObject.Parser, new string[5] { "Children", "Attributes", "SlotVariables", "RegisteredSaver", "HasCheckpointValues" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[3]
					{
						new GeneratedClrTypeInfo(typeof(TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference), (MessageParser)(object)TrackableObjectGraph.Types.TrackableObject.Types.ObjectReference.Parser, new string[2] { "NodeId", "LocalName" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
						new GeneratedClrTypeInfo(typeof(TrackableObjectGraph.Types.TrackableObject.Types.SerializedTensor), (MessageParser)(object)TrackableObjectGraph.Types.TrackableObject.Types.SerializedTensor.Parser, new string[3] { "Name", "FullName", "CheckpointKey" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
						new GeneratedClrTypeInfo(typeof(TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference), (MessageParser)(object)TrackableObjectGraph.Types.TrackableObject.Types.SlotVariableReference.Parser, new string[3] { "OriginalVariableNodeId", "SlotName", "SlotVariableNodeId" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
					})
				}),
				new GeneratedClrTypeInfo(typeof(RegisteredSaver), (MessageParser)(object)RegisteredSaver.Parser, new string[2] { "Name", "ObjectName" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class TrackableObjectGraph : IMessage<TrackableObjectGraph>, IMessage, IEquatable<TrackableObjectGraph>, IDeepCloneable<TrackableObjectGraph>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public sealed class TrackableObject : IMessage<TrackableObject>, IMessage, IEquatable<TrackableObject>, IDeepCloneable<TrackableObject>
			{
				[DebuggerNonUserCode]
				public static class Types
				{
					public sealed class ObjectReference : IMessage<ObjectReference>, IMessage, IEquatable<ObjectReference>, IDeepCloneable<ObjectReference>
					{
						private static readonly MessageParser<ObjectReference> _parser = new MessageParser<ObjectReference>((Func<ObjectReference>)(() => new ObjectReference()));

						private UnknownFieldSet _unknownFields;

						public const int NodeIdFieldNumber = 1;

						private int nodeId_;

						public const int LocalNameFieldNumber = 2;

						private string localName_ = "";

						[DebuggerNonUserCode]
						public static MessageParser<ObjectReference> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => TrackableObject.Descriptor.NestedTypes[0];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public int NodeId
						{
							get
							{
								return nodeId_;
							}
							set
							{
								nodeId_ = value;
							}
						}

						[DebuggerNonUserCode]
						public string LocalName
						{
							get
							{
								return localName_;
							}
							set
							{
								localName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
							}
						}

						[DebuggerNonUserCode]
						public ObjectReference()
						{
						}

						[DebuggerNonUserCode]
						public ObjectReference(ObjectReference other)
							: this()
						{
							nodeId_ = other.nodeId_;
							localName_ = other.localName_;
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public ObjectReference Clone()
						{
							return new ObjectReference(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as ObjectReference);
						}

						[DebuggerNonUserCode]
						public bool Equals(ObjectReference other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (NodeId != other.NodeId)
							{
								return false;
							}
							if (LocalName != other.LocalName)
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							if (NodeId != 0)
							{
								num ^= NodeId.GetHashCode();
							}
							if (LocalName.Length != 0)
							{
								num ^= LocalName.GetHashCode();
							}
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							if (NodeId != 0)
							{
								output.WriteRawTag((byte)8);
								output.WriteInt32(NodeId);
							}
							if (LocalName.Length != 0)
							{
								output.WriteRawTag((byte)18);
								output.WriteString(LocalName);
							}
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							if (NodeId != 0)
							{
								num += 1 + CodedOutputStream.ComputeInt32Size(NodeId);
							}
							if (LocalName.Length != 0)
							{
								num += 1 + CodedOutputStream.ComputeStringSize(LocalName);
							}
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(ObjectReference other)
						{
							if (other != null)
							{
								if (other.NodeId != 0)
								{
									NodeId = other.NodeId;
								}
								if (other.LocalName.Length != 0)
								{
									LocalName = other.LocalName;
								}
								_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
							}
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								switch (num)
								{
								default:
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
									break;
								case 8u:
									NodeId = input.ReadInt32();
									break;
								case 18u:
									LocalName = input.ReadString();
									break;
								}
							}
						}
					}

					public sealed class SerializedTensor : IMessage<SerializedTensor>, IMessage, IEquatable<SerializedTensor>, IDeepCloneable<SerializedTensor>
					{
						private static readonly MessageParser<SerializedTensor> _parser = new MessageParser<SerializedTensor>((Func<SerializedTensor>)(() => new SerializedTensor()));

						private UnknownFieldSet _unknownFields;

						public const int NameFieldNumber = 1;

						private string name_ = "";

						public const int FullNameFieldNumber = 2;

						private string fullName_ = "";

						public const int CheckpointKeyFieldNumber = 3;

						private string checkpointKey_ = "";

						[DebuggerNonUserCode]
						public static MessageParser<SerializedTensor> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => TrackableObject.Descriptor.NestedTypes[1];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public string Name
						{
							get
							{
								return name_;
							}
							set
							{
								name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
							}
						}

						[DebuggerNonUserCode]
						public string FullName
						{
							get
							{
								return fullName_;
							}
							set
							{
								fullName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
							}
						}

						[DebuggerNonUserCode]
						public string CheckpointKey
						{
							get
							{
								return checkpointKey_;
							}
							set
							{
								checkpointKey_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
							}
						}

						[DebuggerNonUserCode]
						public SerializedTensor()
						{
						}

						[DebuggerNonUserCode]
						public SerializedTensor(SerializedTensor other)
							: this()
						{
							name_ = other.name_;
							fullName_ = other.fullName_;
							checkpointKey_ = other.checkpointKey_;
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public SerializedTensor Clone()
						{
							return new SerializedTensor(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as SerializedTensor);
						}

						[DebuggerNonUserCode]
						public bool Equals(SerializedTensor other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (Name != other.Name)
							{
								return false;
							}
							if (FullName != other.FullName)
							{
								return false;
							}
							if (CheckpointKey != other.CheckpointKey)
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							if (Name.Length != 0)
							{
								num ^= Name.GetHashCode();
							}
							if (FullName.Length != 0)
							{
								num ^= FullName.GetHashCode();
							}
							if (CheckpointKey.Length != 0)
							{
								num ^= CheckpointKey.GetHashCode();
							}
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							if (Name.Length != 0)
							{
								output.WriteRawTag((byte)10);
								output.WriteString(Name);
							}
							if (FullName.Length != 0)
							{
								output.WriteRawTag((byte)18);
								output.WriteString(FullName);
							}
							if (CheckpointKey.Length != 0)
							{
								output.WriteRawTag((byte)26);
								output.WriteString(CheckpointKey);
							}
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							if (Name.Length != 0)
							{
								num += 1 + CodedOutputStream.ComputeStringSize(Name);
							}
							if (FullName.Length != 0)
							{
								num += 1 + CodedOutputStream.ComputeStringSize(FullName);
							}
							if (CheckpointKey.Length != 0)
							{
								num += 1 + CodedOutputStream.ComputeStringSize(CheckpointKey);
							}
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(SerializedTensor other)
						{
							if (other != null)
							{
								if (other.Name.Length != 0)
								{
									Name = other.Name;
								}
								if (other.FullName.Length != 0)
								{
									FullName = other.FullName;
								}
								if (other.CheckpointKey.Length != 0)
								{
									CheckpointKey = other.CheckpointKey;
								}
								_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
							}
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								switch (num)
								{
								default:
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
									break;
								case 10u:
									Name = input.ReadString();
									break;
								case 18u:
									FullName = input.ReadString();
									break;
								case 26u:
									CheckpointKey = input.ReadString();
									break;
								}
							}
						}
					}

					public sealed class SlotVariableReference : IMessage<SlotVariableReference>, IMessage, IEquatable<SlotVariableReference>, IDeepCloneable<SlotVariableReference>
					{
						private static readonly MessageParser<SlotVariableReference> _parser = new MessageParser<SlotVariableReference>((Func<SlotVariableReference>)(() => new SlotVariableReference()));

						private UnknownFieldSet _unknownFields;

						public const int OriginalVariableNodeIdFieldNumber = 1;

						private int originalVariableNodeId_;

						public const int SlotNameFieldNumber = 2;

						private string slotName_ = "";

						public const int SlotVariableNodeIdFieldNumber = 3;

						private int slotVariableNodeId_;

						[DebuggerNonUserCode]
						public static MessageParser<SlotVariableReference> Parser => _parser;

						[DebuggerNonUserCode]
						public static MessageDescriptor Descriptor => TrackableObject.Descriptor.NestedTypes[2];

						[DebuggerNonUserCode]
						MessageDescriptor IMessage.Descriptor => Descriptor;

						[DebuggerNonUserCode]
						public int OriginalVariableNodeId
						{
							get
							{
								return originalVariableNodeId_;
							}
							set
							{
								originalVariableNodeId_ = value;
							}
						}

						[DebuggerNonUserCode]
						public string SlotName
						{
							get
							{
								return slotName_;
							}
							set
							{
								slotName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
							}
						}

						[DebuggerNonUserCode]
						public int SlotVariableNodeId
						{
							get
							{
								return slotVariableNodeId_;
							}
							set
							{
								slotVariableNodeId_ = value;
							}
						}

						[DebuggerNonUserCode]
						public SlotVariableReference()
						{
						}

						[DebuggerNonUserCode]
						public SlotVariableReference(SlotVariableReference other)
							: this()
						{
							originalVariableNodeId_ = other.originalVariableNodeId_;
							slotName_ = other.slotName_;
							slotVariableNodeId_ = other.slotVariableNodeId_;
							_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
						}

						[DebuggerNonUserCode]
						public SlotVariableReference Clone()
						{
							return new SlotVariableReference(this);
						}

						[DebuggerNonUserCode]
						public override bool Equals(object other)
						{
							return Equals(other as SlotVariableReference);
						}

						[DebuggerNonUserCode]
						public bool Equals(SlotVariableReference other)
						{
							if (other == null)
							{
								return false;
							}
							if (other == this)
							{
								return true;
							}
							if (OriginalVariableNodeId != other.OriginalVariableNodeId)
							{
								return false;
							}
							if (SlotName != other.SlotName)
							{
								return false;
							}
							if (SlotVariableNodeId != other.SlotVariableNodeId)
							{
								return false;
							}
							return object.Equals(_unknownFields, other._unknownFields);
						}

						[DebuggerNonUserCode]
						public override int GetHashCode()
						{
							int num = 1;
							if (OriginalVariableNodeId != 0)
							{
								num ^= OriginalVariableNodeId.GetHashCode();
							}
							if (SlotName.Length != 0)
							{
								num ^= SlotName.GetHashCode();
							}
							if (SlotVariableNodeId != 0)
							{
								num ^= SlotVariableNodeId.GetHashCode();
							}
							if (_unknownFields != null)
							{
								num ^= ((object)_unknownFields).GetHashCode();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public override string ToString()
						{
							return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
						}

						[DebuggerNonUserCode]
						public void WriteTo(CodedOutputStream output)
						{
							if (OriginalVariableNodeId != 0)
							{
								output.WriteRawTag((byte)8);
								output.WriteInt32(OriginalVariableNodeId);
							}
							if (SlotName.Length != 0)
							{
								output.WriteRawTag((byte)18);
								output.WriteString(SlotName);
							}
							if (SlotVariableNodeId != 0)
							{
								output.WriteRawTag((byte)24);
								output.WriteInt32(SlotVariableNodeId);
							}
							if (_unknownFields != null)
							{
								_unknownFields.WriteTo(output);
							}
						}

						[DebuggerNonUserCode]
						public int CalculateSize()
						{
							int num = 0;
							if (OriginalVariableNodeId != 0)
							{
								num += 1 + CodedOutputStream.ComputeInt32Size(OriginalVariableNodeId);
							}
							if (SlotName.Length != 0)
							{
								num += 1 + CodedOutputStream.ComputeStringSize(SlotName);
							}
							if (SlotVariableNodeId != 0)
							{
								num += 1 + CodedOutputStream.ComputeInt32Size(SlotVariableNodeId);
							}
							if (_unknownFields != null)
							{
								num += _unknownFields.CalculateSize();
							}
							return num;
						}

						[DebuggerNonUserCode]
						public void MergeFrom(SlotVariableReference other)
						{
							if (other != null)
							{
								if (other.OriginalVariableNodeId != 0)
								{
									OriginalVariableNodeId = other.OriginalVariableNodeId;
								}
								if (other.SlotName.Length != 0)
								{
									SlotName = other.SlotName;
								}
								if (other.SlotVariableNodeId != 0)
								{
									SlotVariableNodeId = other.SlotVariableNodeId;
								}
								_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
							}
						}

						[DebuggerNonUserCode]
						public void MergeFrom(CodedInputStream input)
						{
							uint num;
							while ((num = input.ReadTag()) != 0)
							{
								switch (num)
								{
								default:
									_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
									break;
								case 8u:
									OriginalVariableNodeId = input.ReadInt32();
									break;
								case 18u:
									SlotName = input.ReadString();
									break;
								case 24u:
									SlotVariableNodeId = input.ReadInt32();
									break;
								}
							}
						}
					}
				}

				private static readonly MessageParser<TrackableObject> _parser = new MessageParser<TrackableObject>((Func<TrackableObject>)(() => new TrackableObject()));

				private UnknownFieldSet _unknownFields;

				public const int ChildrenFieldNumber = 1;

				private static readonly FieldCodec<Types.ObjectReference> _repeated_children_codec = FieldCodec.ForMessage<Types.ObjectReference>(10u, Types.ObjectReference.Parser);

				private readonly RepeatedField<Types.ObjectReference> children_ = new RepeatedField<Types.ObjectReference>();

				public const int AttributesFieldNumber = 2;

				private static readonly FieldCodec<Types.SerializedTensor> _repeated_attributes_codec = FieldCodec.ForMessage<Types.SerializedTensor>(18u, Types.SerializedTensor.Parser);

				private readonly RepeatedField<Types.SerializedTensor> attributes_ = new RepeatedField<Types.SerializedTensor>();

				public const int SlotVariablesFieldNumber = 3;

				private static readonly FieldCodec<Types.SlotVariableReference> _repeated_slotVariables_codec = FieldCodec.ForMessage<Types.SlotVariableReference>(26u, Types.SlotVariableReference.Parser);

				private readonly RepeatedField<Types.SlotVariableReference> slotVariables_ = new RepeatedField<Types.SlotVariableReference>();

				public const int RegisteredSaverFieldNumber = 4;

				private RegisteredSaver registeredSaver_;

				public const int HasCheckpointValuesFieldNumber = 5;

				private static readonly FieldCodec<bool?> _single_hasCheckpointValues_codec = FieldCodec.ForStructWrapper<bool>(42u);

				private bool? hasCheckpointValues_;

				[DebuggerNonUserCode]
				public static MessageParser<TrackableObject> Parser => _parser;

				[DebuggerNonUserCode]
				public static MessageDescriptor Descriptor => TrackableObjectGraph.Descriptor.NestedTypes[0];

				[DebuggerNonUserCode]
				MessageDescriptor IMessage.Descriptor => Descriptor;

				[DebuggerNonUserCode]
				public RepeatedField<Types.ObjectReference> Children => children_;

				[DebuggerNonUserCode]
				public RepeatedField<Types.SerializedTensor> Attributes => attributes_;

				[DebuggerNonUserCode]
				public RepeatedField<Types.SlotVariableReference> SlotVariables => slotVariables_;

				[DebuggerNonUserCode]
				public RegisteredSaver RegisteredSaver
				{
					get
					{
						return registeredSaver_;
					}
					set
					{
						registeredSaver_ = value;
					}
				}

				[DebuggerNonUserCode]
				public bool? HasCheckpointValues
				{
					get
					{
						return hasCheckpointValues_;
					}
					set
					{
						hasCheckpointValues_ = value;
					}
				}

				[DebuggerNonUserCode]
				public TrackableObject()
				{
				}

				[DebuggerNonUserCode]
				public TrackableObject(TrackableObject other)
					: this()
				{
					children_ = other.children_.Clone();
					attributes_ = other.attributes_.Clone();
					slotVariables_ = other.slotVariables_.Clone();
					registeredSaver_ = ((other.registeredSaver_ != null) ? other.registeredSaver_.Clone() : null);
					HasCheckpointValues = other.HasCheckpointValues;
					_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
				}

				[DebuggerNonUserCode]
				public TrackableObject Clone()
				{
					return new TrackableObject(this);
				}

				[DebuggerNonUserCode]
				public override bool Equals(object other)
				{
					return Equals(other as TrackableObject);
				}

				[DebuggerNonUserCode]
				public bool Equals(TrackableObject other)
				{
					if (other == null)
					{
						return false;
					}
					if (other == this)
					{
						return true;
					}
					if (!children_.Equals(other.children_))
					{
						return false;
					}
					if (!attributes_.Equals(other.attributes_))
					{
						return false;
					}
					if (!slotVariables_.Equals(other.slotVariables_))
					{
						return false;
					}
					if (!object.Equals(RegisteredSaver, other.RegisteredSaver))
					{
						return false;
					}
					if (HasCheckpointValues != other.HasCheckpointValues)
					{
						return false;
					}
					return object.Equals(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public override int GetHashCode()
				{
					int num = 1;
					num ^= ((object)children_).GetHashCode();
					num ^= ((object)attributes_).GetHashCode();
					num ^= ((object)slotVariables_).GetHashCode();
					if (registeredSaver_ != null)
					{
						num ^= RegisteredSaver.GetHashCode();
					}
					if (hasCheckpointValues_.HasValue)
					{
						num ^= HasCheckpointValues.GetHashCode();
					}
					if (_unknownFields != null)
					{
						num ^= ((object)_unknownFields).GetHashCode();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public override string ToString()
				{
					return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
				}

				[DebuggerNonUserCode]
				public void WriteTo(CodedOutputStream output)
				{
					children_.WriteTo(output, _repeated_children_codec);
					attributes_.WriteTo(output, _repeated_attributes_codec);
					slotVariables_.WriteTo(output, _repeated_slotVariables_codec);
					if (registeredSaver_ != null)
					{
						output.WriteRawTag((byte)34);
						output.WriteMessage((IMessage)(object)RegisteredSaver);
					}
					if (hasCheckpointValues_.HasValue)
					{
						_single_hasCheckpointValues_codec.WriteTagAndValue(output, HasCheckpointValues);
					}
					if (_unknownFields != null)
					{
						_unknownFields.WriteTo(output);
					}
				}

				[DebuggerNonUserCode]
				public int CalculateSize()
				{
					int num = 0;
					num += children_.CalculateSize(_repeated_children_codec);
					num += attributes_.CalculateSize(_repeated_attributes_codec);
					num += slotVariables_.CalculateSize(_repeated_slotVariables_codec);
					if (registeredSaver_ != null)
					{
						num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)RegisteredSaver);
					}
					if (hasCheckpointValues_.HasValue)
					{
						num += _single_hasCheckpointValues_codec.CalculateSizeWithTag(HasCheckpointValues);
					}
					if (_unknownFields != null)
					{
						num += _unknownFields.CalculateSize();
					}
					return num;
				}

				[DebuggerNonUserCode]
				public void MergeFrom(TrackableObject other)
				{
					if (other == null)
					{
						return;
					}
					children_.Add((IEnumerable<Types.ObjectReference>)other.children_);
					attributes_.Add((IEnumerable<Types.SerializedTensor>)other.attributes_);
					slotVariables_.Add((IEnumerable<Types.SlotVariableReference>)other.slotVariables_);
					if (other.registeredSaver_ != null)
					{
						if (registeredSaver_ == null)
						{
							RegisteredSaver = new RegisteredSaver();
						}
						RegisteredSaver.MergeFrom(other.RegisteredSaver);
					}
					if (other.hasCheckpointValues_.HasValue && (!hasCheckpointValues_.HasValue || other.HasCheckpointValues != false))
					{
						HasCheckpointValues = other.HasCheckpointValues;
					}
					_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
				}

				[DebuggerNonUserCode]
				public void MergeFrom(CodedInputStream input)
				{
					uint num;
					while ((num = input.ReadTag()) != 0)
					{
						switch (num)
						{
						default:
							_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
							break;
						case 10u:
							children_.AddEntriesFrom(input, _repeated_children_codec);
							break;
						case 18u:
							attributes_.AddEntriesFrom(input, _repeated_attributes_codec);
							break;
						case 26u:
							slotVariables_.AddEntriesFrom(input, _repeated_slotVariables_codec);
							break;
						case 34u:
							if (registeredSaver_ == null)
							{
								RegisteredSaver = new RegisteredSaver();
							}
							input.ReadMessage((IMessage)(object)RegisteredSaver);
							break;
						case 42u:
						{
							bool? flag = _single_hasCheckpointValues_codec.Read(input);
							if (!hasCheckpointValues_.HasValue || flag != false)
							{
								HasCheckpointValues = flag;
							}
							break;
						}
						}
					}
				}
			}
		}

		private static readonly MessageParser<TrackableObjectGraph> _parser = new MessageParser<TrackableObjectGraph>((Func<TrackableObjectGraph>)(() => new TrackableObjectGraph()));

		private UnknownFieldSet _unknownFields;

		public const int NodesFieldNumber = 1;

		private static readonly FieldCodec<Types.TrackableObject> _repeated_nodes_codec = FieldCodec.ForMessage<Types.TrackableObject>(10u, Types.TrackableObject.Parser);

		private readonly RepeatedField<Types.TrackableObject> nodes_ = new RepeatedField<Types.TrackableObject>();

		[DebuggerNonUserCode]
		public static MessageParser<TrackableObjectGraph> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TrackableObjectGraphReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public RepeatedField<Types.TrackableObject> Nodes => nodes_;

		[DebuggerNonUserCode]
		public TrackableObjectGraph()
		{
		}

		[DebuggerNonUserCode]
		public TrackableObjectGraph(TrackableObjectGraph other)
			: this()
		{
			nodes_ = other.nodes_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public TrackableObjectGraph Clone()
		{
			return new TrackableObjectGraph(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as TrackableObjectGraph);
		}

		[DebuggerNonUserCode]
		public bool Equals(TrackableObjectGraph other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (!nodes_.Equals(other.nodes_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			num ^= ((object)nodes_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			nodes_.WriteTo(output, _repeated_nodes_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			num += nodes_.CalculateSize(_repeated_nodes_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(TrackableObjectGraph other)
		{
			if (other != null)
			{
				nodes_.Add((IEnumerable<Types.TrackableObject>)other.nodes_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				if (num != 10)
				{
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
				}
				else
				{
					nodes_.AddEntriesFrom(input, _repeated_nodes_codec);
				}
			}
		}
	}
	public sealed class RegisteredSaver : IMessage<RegisteredSaver>, IMessage, IEquatable<RegisteredSaver>, IDeepCloneable<RegisteredSaver>
	{
		private static readonly MessageParser<RegisteredSaver> _parser = new MessageParser<RegisteredSaver>((Func<RegisteredSaver>)(() => new RegisteredSaver()));

		private UnknownFieldSet _unknownFields;

		public const int NameFieldNumber = 1;

		private string name_ = "";

		public const int ObjectNameFieldNumber = 2;

		private string objectName_ = "";

		[DebuggerNonUserCode]
		public static MessageParser<RegisteredSaver> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => TrackableObjectGraphReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string Name
		{
			get
			{
				return name_;
			}
			set
			{
				name_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string ObjectName
		{
			get
			{
				return objectName_;
			}
			set
			{
				objectName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RegisteredSaver()
		{
		}

		[DebuggerNonUserCode]
		public RegisteredSaver(RegisteredSaver other)
			: this()
		{
			name_ = other.name_;
			objectName_ = other.objectName_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public RegisteredSaver Clone()
		{
			return new RegisteredSaver(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as RegisteredSaver);
		}

		[DebuggerNonUserCode]
		public bool Equals(RegisteredSaver other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Name != other.Name)
			{
				return false;
			}
			if (ObjectName != other.ObjectName)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Name.Length != 0)
			{
				num ^= Name.GetHashCode();
			}
			if (ObjectName.Length != 0)
			{
				num ^= ObjectName.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Name.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(Name);
			}
			if (ObjectName.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(ObjectName);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Name.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(Name);
			}
			if (ObjectName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(ObjectName);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(RegisteredSaver other)
		{
			if (other != null)
			{
				if (other.Name.Length != 0)
				{
					Name = other.Name;
				}
				if (other.ObjectName.Length != 0)
				{
					ObjectName = other.ObjectName;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					Name = input.ReadString();
					break;
				case 18u:
					ObjectName = input.ReadString();
					break;
				}
			}
		}
	}
	public static class TypesReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static TypesReflection()
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("CiR0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdHlwZXMucHJvdG8SC3RlbnNv" + "cmJvYXJkKqoGCghEYXRhVHlwZRIOCgpEVF9JTlZBTElEEAASDAoIRFRfRkxP" + "QVQQARINCglEVF9ET1VCTEUQAhIMCghEVF9JTlQzMhADEgwKCERUX1VJTlQ4" + "EAQSDAoIRFRfSU5UMTYQBRILCgdEVF9JTlQ4EAYSDQoJRFRfU1RSSU5HEAcS" + "EAoMRFRfQ09NUExFWDY0EAgSDAoIRFRfSU5UNjQQCRILCgdEVF9CT09MEAoS" + "DAoIRFRfUUlOVDgQCxINCglEVF9RVUlOVDgQDBINCglEVF9RSU5UMzIQDRIP" + "CgtEVF9CRkxPQVQxNhAOEg0KCURUX1FJTlQxNhAPEg4KCkRUX1FVSU5UMTYQ" + "EBINCglEVF9VSU5UMTYQERIRCg1EVF9DT01QTEVYMTI4EBISCwoHRFRfSEFM" + "RhATEg8KC0RUX1JFU09VUkNFEBQSDgoKRFRfVkFSSUFOVBAVEg0KCURUX1VJ" + "TlQzMhAWEg0KCURUX1VJTlQ2NBAXEhAKDERUX0ZMT0FUX1JFRhBlEhEKDURU" + "X0RPVUJMRV9SRUYQZhIQCgxEVF9JTlQzMl9SRUYQZxIQCgxEVF9VSU5UOF9S" + "RUYQaBIQCgxEVF9JTlQxNl9SRUYQaRIPCgtEVF9JTlQ4X1JFRhBqEhEKDURU" + "X1NUUklOR19SRUYQaxIUChBEVF9DT01QTEVYNjRfUkVGEGwSEAoMRFRfSU5U" + "NjRfUkVGEG0SDwoLRFRfQk9PTF9SRUYQbhIQCgxEVF9RSU5UOF9SRUYQbxIR" + "Cg1EVF9RVUlOVDhfUkVGEHASEQoNRFRfUUlOVDMyX1JFRhBxEhMKD0RUX0JG" + "TE9BVDE2X1JFRhByEhEKDURUX1FJTlQxNl9SRUYQcxISCg5EVF9RVUlOVDE2" + "X1JFRhB0EhEKDURUX1VJTlQxNl9SRUYQdRIVChFEVF9DT01QTEVYMTI4X1JF" + "RhB2Eg8KC0RUX0hBTEZfUkVGEHcSEwoPRFRfUkVTT1VSQ0VfUkVGEHgSEgoO" + "RFRfVkFSSUFOVF9SRUYQeRIRCg1EVF9VSU5UMzJfUkVGEHoSEQoNRFRfVUlO" + "VDY0X1JFRhB7QnoKGG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0ILVHlwZXNQ" + "cm90b3NQAVpMZ2l0aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVu" + "c29yZmxvdy9nby9jb3JlL2ZyYW1ld29yay90eXBlc19nb19wcm90b/gBAWIG" + "cHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo(new Type[1] { typeof(DataType) }, (Extension[])null, (GeneratedClrTypeInfo[])null));
		}
	}
	public enum DataType
	{
		[OriginalName("DT_INVALID")]
		DtInvalid = 0,
		[OriginalName("DT_FLOAT")]
		DtFloat = 1,
		[OriginalName("DT_DOUBLE")]
		DtDouble = 2,
		[OriginalName("DT_INT32")]
		DtInt32 = 3,
		[OriginalName("DT_UINT8")]
		DtUint8 = 4,
		[OriginalName("DT_INT16")]
		DtInt16 = 5,
		[OriginalName("DT_INT8")]
		DtInt8 = 6,
		[OriginalName("DT_STRING")]
		DtString = 7,
		[OriginalName("DT_COMPLEX64")]
		DtComplex64 = 8,
		[OriginalName("DT_INT64")]
		DtInt64 = 9,
		[OriginalName("DT_BOOL")]
		DtBool = 10,
		[OriginalName("DT_QINT8")]
		DtQint8 = 11,
		[OriginalName("DT_QUINT8")]
		DtQuint8 = 12,
		[OriginalName("DT_QINT32")]
		DtQint32 = 13,
		[OriginalName("DT_BFLOAT16")]
		DtBfloat16 = 14,
		[OriginalName("DT_QINT16")]
		DtQint16 = 15,
		[OriginalName("DT_QUINT16")]
		DtQuint16 = 16,
		[OriginalName("DT_UINT16")]
		DtUint16 = 17,
		[OriginalName("DT_COMPLEX128")]
		DtComplex128 = 18,
		[OriginalName("DT_HALF")]
		DtHalf = 19,
		[OriginalName("DT_RESOURCE")]
		DtResource = 20,
		[OriginalName("DT_VARIANT")]
		DtVariant = 21,
		[OriginalName("DT_UINT32")]
		DtUint32 = 22,
		[OriginalName("DT_UINT64")]
		DtUint64 = 23,
		[OriginalName("DT_FLOAT_REF")]
		DtFloatRef = 101,
		[OriginalName("DT_DOUBLE_REF")]
		DtDoubleRef = 102,
		[OriginalName("DT_INT32_REF")]
		DtInt32Ref = 103,
		[OriginalName("DT_UINT8_REF")]
		DtUint8Ref = 104,
		[OriginalName("DT_INT16_REF")]
		DtInt16Ref = 105,
		[OriginalName("DT_INT8_REF")]
		DtInt8Ref = 106,
		[OriginalName("DT_STRING_REF")]
		DtStringRef = 107,
		[OriginalName("DT_COMPLEX64_REF")]
		DtComplex64Ref = 108,
		[OriginalName("DT_INT64_REF")]
		DtInt64Ref = 109,
		[OriginalName("DT_BOOL_REF")]
		DtBoolRef = 110,
		[OriginalName("DT_QINT8_REF")]
		DtQint8Ref = 111,
		[OriginalName("DT_QUINT8_REF")]
		DtQuint8Ref = 112,
		[OriginalName("DT_QINT32_REF")]
		DtQint32Ref = 113,
		[OriginalName("DT_BFLOAT16_REF")]
		DtBfloat16Ref = 114,
		[OriginalName("DT_QINT16_REF")]
		DtQint16Ref = 115,
		[OriginalName("DT_QUINT16_REF")]
		DtQuint16Ref = 116,
		[OriginalName("DT_UINT16_REF")]
		DtUint16Ref = 117,
		[OriginalName("DT_COMPLEX128_REF")]
		DtComplex128Ref = 118,
		[OriginalName("DT_HALF_REF")]
		DtHalfRef = 119,
		[OriginalName("DT_RESOURCE_REF")]
		DtResourceRef = 120,
		[OriginalName("DT_VARIANT_REF")]
		DtVariantRef = 121,
		[OriginalName("DT_UINT32_REF")]
		DtUint32Ref = 122,
		[OriginalName("DT_UINT64_REF")]
		DtUint64Ref = 123
	}
	public static class VariableReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static VariableReflection()
		{
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Expected O, but got Unknown
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cid0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdmFyaWFibGUucHJvdG8SC3Rl" + "bnNvcmJvYXJkIssCCgtWYXJpYWJsZURlZhIVCg12YXJpYWJsZV9uYW1lGAEg" + "ASgJEhoKEmluaXRpYWxfdmFsdWVfbmFtZRgGIAEoCRIYChBpbml0aWFsaXpl" + "cl9uYW1lGAIgASgJEhUKDXNuYXBzaG90X25hbWUYAyABKAkSOgoTc2F2ZV9z" + "bGljZV9pbmZvX2RlZhgEIAEoCzIdLnRlbnNvcmJvYXJkLlNhdmVTbGljZUlu" + "Zm9EZWYSEwoLaXNfcmVzb3VyY2UYBSABKAgSEQoJdHJhaW5hYmxlGAcgASgI" + "Ej0KD3N5bmNocm9uaXphdGlvbhgIIAEoDjIkLnRlbnNvcmJvYXJkLlZhcmlh" + "YmxlU3luY2hyb25pemF0aW9uEjUKC2FnZ3JlZ2F0aW9uGAkgASgOMiAudGVu" + "c29yYm9hcmQuVmFyaWFibGVBZ2dyZWdhdGlvbiJgChBTYXZlU2xpY2VJbmZv" + "RGVmEhEKCWZ1bGxfbmFtZRgBIAEoCRISCgpmdWxsX3NoYXBlGAIgAygDEhIK" + "CnZhcl9vZmZzZXQYAyADKAMSEQoJdmFyX3NoYXBlGAQgAygDKqwBChdWYXJp" + "YWJsZVN5bmNocm9uaXphdGlvbhIhCh1WQVJJQUJMRV9TWU5DSFJPTklaQVRJ" + "T05fQVVUTxAAEiEKHVZBUklBQkxFX1NZTkNIUk9OSVpBVElPTl9OT05FEAES" + "JQohVkFSSUFCTEVfU1lOQ0hST05JWkFUSU9OX09OX1dSSVRFEAISJAogVkFS" + "SUFCTEVfU1lOQ0hST05JWkFUSU9OX09OX1JFQUQQAyqeAQoTVmFyaWFibGVB" + "Z2dyZWdhdGlvbhIdChlWQVJJQUJMRV9BR0dSRUdBVElPTl9OT05FEAASHAoY" + "VkFSSUFCTEVfQUdHUkVHQVRJT05fU1VNEAESHQoZVkFSSUFCTEVfQUdHUkVH" + "QVRJT05fTUVBThACEisKJ1ZBUklBQkxFX0FHR1JFR0FUSU9OX09OTFlfRklS" + "U1RfUkVQTElDQRADQoABChhvcmcudGVuc29yZmxvdy5mcmFtZXdvcmtCDlZh" + "cmlhYmxlUHJvdG9zUAFaT2dpdGh1Yi5jb20vdGVuc29yZmxvdy90ZW5zb3Jm" + "bG93L3RlbnNvcmZsb3cvZ28vY29yZS9mcmFtZXdvcmsvdmFyaWFibGVfZ29f" + "cHJvdG/4AQFiBnByb3RvMw=="), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo(new Type[2]
			{
				typeof(VariableSynchronization),
				typeof(VariableAggregation)
			}, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[2]
			{
				new GeneratedClrTypeInfo(typeof(VariableDef), (MessageParser)(object)VariableDef.Parser, new string[9] { "VariableName", "InitialValueName", "InitializerName", "SnapshotName", "SaveSliceInfoDef", "IsResource", "Trainable", "Synchronization", "Aggregation" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null),
				new GeneratedClrTypeInfo(typeof(SaveSliceInfoDef), (MessageParser)(object)SaveSliceInfoDef.Parser, new string[4] { "FullName", "FullShape", "VarOffset", "VarShape" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public enum VariableSynchronization
	{
		[OriginalName("VARIABLE_SYNCHRONIZATION_AUTO")]
		Auto,
		[OriginalName("VARIABLE_SYNCHRONIZATION_NONE")]
		None,
		[OriginalName("VARIABLE_SYNCHRONIZATION_ON_WRITE")]
		OnWrite,
		[OriginalName("VARIABLE_SYNCHRONIZATION_ON_READ")]
		OnRead
	}
	public enum VariableAggregation
	{
		[OriginalName("VARIABLE_AGGREGATION_NONE")]
		None,
		[OriginalName("VARIABLE_AGGREGATION_SUM")]
		Sum,
		[OriginalName("VARIABLE_AGGREGATION_MEAN")]
		Mean,
		[OriginalName("VARIABLE_AGGREGATION_ONLY_FIRST_REPLICA")]
		OnlyFirstReplica
	}
	public sealed class VariableDef : IMessage<VariableDef>, IMessage, IEquatable<VariableDef>, IDeepCloneable<VariableDef>
	{
		private static readonly MessageParser<VariableDef> _parser = new MessageParser<VariableDef>((Func<VariableDef>)(() => new VariableDef()));

		private UnknownFieldSet _unknownFields;

		public const int VariableNameFieldNumber = 1;

		private string variableName_ = "";

		public const int InitialValueNameFieldNumber = 6;

		private string initialValueName_ = "";

		public const int InitializerNameFieldNumber = 2;

		private string initializerName_ = "";

		public const int SnapshotNameFieldNumber = 3;

		private string snapshotName_ = "";

		public const int SaveSliceInfoDefFieldNumber = 4;

		private SaveSliceInfoDef saveSliceInfoDef_;

		public const int IsResourceFieldNumber = 5;

		private bool isResource_;

		public const int TrainableFieldNumber = 7;

		private bool trainable_;

		public const int SynchronizationFieldNumber = 8;

		private VariableSynchronization synchronization_;

		public const int AggregationFieldNumber = 9;

		private VariableAggregation aggregation_;

		[DebuggerNonUserCode]
		public static MessageParser<VariableDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => VariableReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string VariableName
		{
			get
			{
				return variableName_;
			}
			set
			{
				variableName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string InitialValueName
		{
			get
			{
				return initialValueName_;
			}
			set
			{
				initialValueName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string InitializerName
		{
			get
			{
				return initializerName_;
			}
			set
			{
				initializerName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public string SnapshotName
		{
			get
			{
				return snapshotName_;
			}
			set
			{
				snapshotName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public SaveSliceInfoDef SaveSliceInfoDef
		{
			get
			{
				return saveSliceInfoDef_;
			}
			set
			{
				saveSliceInfoDef_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool IsResource
		{
			get
			{
				return isResource_;
			}
			set
			{
				isResource_ = value;
			}
		}

		[DebuggerNonUserCode]
		public bool Trainable
		{
			get
			{
				return trainable_;
			}
			set
			{
				trainable_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VariableSynchronization Synchronization
		{
			get
			{
				return synchronization_;
			}
			set
			{
				synchronization_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VariableAggregation Aggregation
		{
			get
			{
				return aggregation_;
			}
			set
			{
				aggregation_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VariableDef()
		{
		}

		[DebuggerNonUserCode]
		public VariableDef(VariableDef other)
			: this()
		{
			variableName_ = other.variableName_;
			initialValueName_ = other.initialValueName_;
			initializerName_ = other.initializerName_;
			snapshotName_ = other.snapshotName_;
			saveSliceInfoDef_ = ((other.saveSliceInfoDef_ != null) ? other.saveSliceInfoDef_.Clone() : null);
			isResource_ = other.isResource_;
			trainable_ = other.trainable_;
			synchronization_ = other.synchronization_;
			aggregation_ = other.aggregation_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public VariableDef Clone()
		{
			return new VariableDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as VariableDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(VariableDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (VariableName != other.VariableName)
			{
				return false;
			}
			if (InitialValueName != other.InitialValueName)
			{
				return false;
			}
			if (InitializerName != other.InitializerName)
			{
				return false;
			}
			if (SnapshotName != other.SnapshotName)
			{
				return false;
			}
			if (!object.Equals(SaveSliceInfoDef, other.SaveSliceInfoDef))
			{
				return false;
			}
			if (IsResource != other.IsResource)
			{
				return false;
			}
			if (Trainable != other.Trainable)
			{
				return false;
			}
			if (Synchronization != other.Synchronization)
			{
				return false;
			}
			if (Aggregation != other.Aggregation)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (VariableName.Length != 0)
			{
				num ^= VariableName.GetHashCode();
			}
			if (InitialValueName.Length != 0)
			{
				num ^= InitialValueName.GetHashCode();
			}
			if (InitializerName.Length != 0)
			{
				num ^= InitializerName.GetHashCode();
			}
			if (SnapshotName.Length != 0)
			{
				num ^= SnapshotName.GetHashCode();
			}
			if (saveSliceInfoDef_ != null)
			{
				num ^= SaveSliceInfoDef.GetHashCode();
			}
			if (IsResource)
			{
				num ^= IsResource.GetHashCode();
			}
			if (Trainable)
			{
				num ^= Trainable.GetHashCode();
			}
			if (Synchronization != VariableSynchronization.Auto)
			{
				num ^= Synchronization.GetHashCode();
			}
			if (Aggregation != VariableAggregation.None)
			{
				num ^= Aggregation.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (VariableName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(VariableName);
			}
			if (InitializerName.Length != 0)
			{
				output.WriteRawTag((byte)18);
				output.WriteString(InitializerName);
			}
			if (SnapshotName.Length != 0)
			{
				output.WriteRawTag((byte)26);
				output.WriteString(SnapshotName);
			}
			if (saveSliceInfoDef_ != null)
			{
				output.WriteRawTag((byte)34);
				output.WriteMessage((IMessage)(object)SaveSliceInfoDef);
			}
			if (IsResource)
			{
				output.WriteRawTag((byte)40);
				output.WriteBool(IsResource);
			}
			if (InitialValueName.Length != 0)
			{
				output.WriteRawTag((byte)50);
				output.WriteString(InitialValueName);
			}
			if (Trainable)
			{
				output.WriteRawTag((byte)56);
				output.WriteBool(Trainable);
			}
			if (Synchronization != VariableSynchronization.Auto)
			{
				output.WriteRawTag((byte)64);
				output.WriteEnum((int)Synchronization);
			}
			if (Aggregation != VariableAggregation.None)
			{
				output.WriteRawTag((byte)72);
				output.WriteEnum((int)Aggregation);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (VariableName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(VariableName);
			}
			if (InitialValueName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(InitialValueName);
			}
			if (InitializerName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(InitializerName);
			}
			if (SnapshotName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(SnapshotName);
			}
			if (saveSliceInfoDef_ != null)
			{
				num += 1 + CodedOutputStream.ComputeMessageSize((IMessage)(object)SaveSliceInfoDef);
			}
			if (IsResource)
			{
				num += 2;
			}
			if (Trainable)
			{
				num += 2;
			}
			if (Synchronization != VariableSynchronization.Auto)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Synchronization);
			}
			if (Aggregation != VariableAggregation.None)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)Aggregation);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(VariableDef other)
		{
			if (other == null)
			{
				return;
			}
			if (other.VariableName.Length != 0)
			{
				VariableName = other.VariableName;
			}
			if (other.InitialValueName.Length != 0)
			{
				InitialValueName = other.InitialValueName;
			}
			if (other.InitializerName.Length != 0)
			{
				InitializerName = other.InitializerName;
			}
			if (other.SnapshotName.Length != 0)
			{
				SnapshotName = other.SnapshotName;
			}
			if (other.saveSliceInfoDef_ != null)
			{
				if (saveSliceInfoDef_ == null)
				{
					SaveSliceInfoDef = new SaveSliceInfoDef();
				}
				SaveSliceInfoDef.MergeFrom(other.SaveSliceInfoDef);
			}
			if (other.IsResource)
			{
				IsResource = other.IsResource;
			}
			if (other.Trainable)
			{
				Trainable = other.Trainable;
			}
			if (other.Synchronization != VariableSynchronization.Auto)
			{
				Synchronization = other.Synchronization;
			}
			if (other.Aggregation != VariableAggregation.None)
			{
				Aggregation = other.Aggregation;
			}
			_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					VariableName = input.ReadString();
					break;
				case 18u:
					InitializerName = input.ReadString();
					break;
				case 26u:
					SnapshotName = input.ReadString();
					break;
				case 34u:
					if (saveSliceInfoDef_ == null)
					{
						SaveSliceInfoDef = new SaveSliceInfoDef();
					}
					input.ReadMessage((IMessage)(object)SaveSliceInfoDef);
					break;
				case 40u:
					IsResource = input.ReadBool();
					break;
				case 50u:
					InitialValueName = input.ReadString();
					break;
				case 56u:
					Trainable = input.ReadBool();
					break;
				case 64u:
					Synchronization = (VariableSynchronization)input.ReadEnum();
					break;
				case 72u:
					Aggregation = (VariableAggregation)input.ReadEnum();
					break;
				}
			}
		}
	}
	public sealed class SaveSliceInfoDef : IMessage<SaveSliceInfoDef>, IMessage, IEquatable<SaveSliceInfoDef>, IDeepCloneable<SaveSliceInfoDef>
	{
		private static readonly MessageParser<SaveSliceInfoDef> _parser = new MessageParser<SaveSliceInfoDef>((Func<SaveSliceInfoDef>)(() => new SaveSliceInfoDef()));

		private UnknownFieldSet _unknownFields;

		public const int FullNameFieldNumber = 1;

		private string fullName_ = "";

		public const int FullShapeFieldNumber = 2;

		private static readonly FieldCodec<long> _repeated_fullShape_codec = FieldCodec.ForInt64(18u);

		private readonly RepeatedField<long> fullShape_ = new RepeatedField<long>();

		public const int VarOffsetFieldNumber = 3;

		private static readonly FieldCodec<long> _repeated_varOffset_codec = FieldCodec.ForInt64(26u);

		private readonly RepeatedField<long> varOffset_ = new RepeatedField<long>();

		public const int VarShapeFieldNumber = 4;

		private static readonly FieldCodec<long> _repeated_varShape_codec = FieldCodec.ForInt64(34u);

		private readonly RepeatedField<long> varShape_ = new RepeatedField<long>();

		[DebuggerNonUserCode]
		public static MessageParser<SaveSliceInfoDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => VariableReflection.Descriptor.MessageTypes[1];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public string FullName
		{
			get
			{
				return fullName_;
			}
			set
			{
				fullName_ = ProtoPreconditions.CheckNotNull<string>(value, "value");
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<long> FullShape => fullShape_;

		[DebuggerNonUserCode]
		public RepeatedField<long> VarOffset => varOffset_;

		[DebuggerNonUserCode]
		public RepeatedField<long> VarShape => varShape_;

		[DebuggerNonUserCode]
		public SaveSliceInfoDef()
		{
		}

		[DebuggerNonUserCode]
		public SaveSliceInfoDef(SaveSliceInfoDef other)
			: this()
		{
			fullName_ = other.fullName_;
			fullShape_ = other.fullShape_.Clone();
			varOffset_ = other.varOffset_.Clone();
			varShape_ = other.varShape_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public SaveSliceInfoDef Clone()
		{
			return new SaveSliceInfoDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as SaveSliceInfoDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(SaveSliceInfoDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (FullName != other.FullName)
			{
				return false;
			}
			if (!fullShape_.Equals(other.fullShape_))
			{
				return false;
			}
			if (!varOffset_.Equals(other.varOffset_))
			{
				return false;
			}
			if (!varShape_.Equals(other.varShape_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (FullName.Length != 0)
			{
				num ^= FullName.GetHashCode();
			}
			num ^= ((object)fullShape_).GetHashCode();
			num ^= ((object)varOffset_).GetHashCode();
			num ^= ((object)varShape_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (FullName.Length != 0)
			{
				output.WriteRawTag((byte)10);
				output.WriteString(FullName);
			}
			fullShape_.WriteTo(output, _repeated_fullShape_codec);
			varOffset_.WriteTo(output, _repeated_varOffset_codec);
			varShape_.WriteTo(output, _repeated_varShape_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (FullName.Length != 0)
			{
				num += 1 + CodedOutputStream.ComputeStringSize(FullName);
			}
			num += fullShape_.CalculateSize(_repeated_fullShape_codec);
			num += varOffset_.CalculateSize(_repeated_varOffset_codec);
			num += varShape_.CalculateSize(_repeated_varShape_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(SaveSliceInfoDef other)
		{
			if (other != null)
			{
				if (other.FullName.Length != 0)
				{
					FullName = other.FullName;
				}
				fullShape_.Add((IEnumerable<long>)other.fullShape_);
				varOffset_.Add((IEnumerable<long>)other.varOffset_);
				varShape_.Add((IEnumerable<long>)other.varShape_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 10u:
					FullName = input.ReadString();
					break;
				case 16u:
				case 18u:
					fullShape_.AddEntriesFrom(input, _repeated_fullShape_codec);
					break;
				case 24u:
				case 26u:
					varOffset_.AddEntriesFrom(input, _repeated_varOffset_codec);
					break;
				case 32u:
				case 34u:
					varShape_.AddEntriesFrom(input, _repeated_varShape_codec);
					break;
				}
			}
		}
	}
	public static class VerifierConfigReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static VerifierConfigReflection()
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Ci50ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdmVyaWZpZXJfY29uZmlnLnBy" + "b3RvEgt0ZW5zb3Jib2FyZCKcAQoOVmVyaWZpZXJDb25maWcSIgoadmVyaWZp" + "Y2F0aW9uX3RpbWVvdXRfaW5fbXMYASABKAMSPgoSc3RydWN0dXJlX3Zlcmlm" + "aWVyGAIgASgOMiIudGVuc29yYm9hcmQuVmVyaWZpZXJDb25maWcuVG9nZ2xl" + "IiYKBlRvZ2dsZRILCgdERUZBVUxUEAASBgoCT04QARIHCgNPRkYQAkKMAQoY" + "b3JnLnRlbnNvcmZsb3cuZnJhbWV3b3JrQhRWZXJpZmllckNvbmZpZ1Byb3Rv" + "c1ABWlVnaXRodWIuY29tL3RlbnNvcmZsb3cvdGVuc29yZmxvdy90ZW5zb3Jm" + "bG93L2dvL2NvcmUvcHJvdG9idWYvZm9yX2NvcmVfcHJvdG9zX2dvX3Byb3Rv" + "+AEBYgZwcm90bzM="), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(VerifierConfig), (MessageParser)(object)VerifierConfig.Parser, new string[2] { "VerificationTimeoutInMs", "StructureVerifier" }, (string[])null, new Type[1] { typeof(VerifierConfig.Types.Toggle) }, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class VerifierConfig : IMessage<VerifierConfig>, IMessage, IEquatable<VerifierConfig>, IDeepCloneable<VerifierConfig>
	{
		[DebuggerNonUserCode]
		public static class Types
		{
			public enum Toggle
			{
				[OriginalName("DEFAULT")]
				Default,
				[OriginalName("ON")]
				On,
				[OriginalName("OFF")]
				Off
			}
		}

		private static readonly MessageParser<VerifierConfig> _parser = new MessageParser<VerifierConfig>((Func<VerifierConfig>)(() => new VerifierConfig()));

		private UnknownFieldSet _unknownFields;

		public const int VerificationTimeoutInMsFieldNumber = 1;

		private long verificationTimeoutInMs_;

		public const int StructureVerifierFieldNumber = 2;

		private Types.Toggle structureVerifier_;

		[DebuggerNonUserCode]
		public static MessageParser<VerifierConfig> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => VerifierConfigReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public long VerificationTimeoutInMs
		{
			get
			{
				return verificationTimeoutInMs_;
			}
			set
			{
				verificationTimeoutInMs_ = value;
			}
		}

		[DebuggerNonUserCode]
		public Types.Toggle StructureVerifier
		{
			get
			{
				return structureVerifier_;
			}
			set
			{
				structureVerifier_ = value;
			}
		}

		[DebuggerNonUserCode]
		public VerifierConfig()
		{
		}

		[DebuggerNonUserCode]
		public VerifierConfig(VerifierConfig other)
			: this()
		{
			verificationTimeoutInMs_ = other.verificationTimeoutInMs_;
			structureVerifier_ = other.structureVerifier_;
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public VerifierConfig Clone()
		{
			return new VerifierConfig(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as VerifierConfig);
		}

		[DebuggerNonUserCode]
		public bool Equals(VerifierConfig other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (VerificationTimeoutInMs != other.VerificationTimeoutInMs)
			{
				return false;
			}
			if (StructureVerifier != other.StructureVerifier)
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (VerificationTimeoutInMs != 0L)
			{
				num ^= VerificationTimeoutInMs.GetHashCode();
			}
			if (StructureVerifier != Types.Toggle.Default)
			{
				num ^= StructureVerifier.GetHashCode();
			}
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (VerificationTimeoutInMs != 0L)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt64(VerificationTimeoutInMs);
			}
			if (StructureVerifier != Types.Toggle.Default)
			{
				output.WriteRawTag((byte)16);
				output.WriteEnum((int)StructureVerifier);
			}
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (VerificationTimeoutInMs != 0L)
			{
				num += 1 + CodedOutputStream.ComputeInt64Size(VerificationTimeoutInMs);
			}
			if (StructureVerifier != Types.Toggle.Default)
			{
				num += 1 + CodedOutputStream.ComputeEnumSize((int)StructureVerifier);
			}
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(VerifierConfig other)
		{
			if (other != null)
			{
				if (other.VerificationTimeoutInMs != 0L)
				{
					VerificationTimeoutInMs = other.VerificationTimeoutInMs;
				}
				if (other.StructureVerifier != Types.Toggle.Default)
				{
					StructureVerifier = other.StructureVerifier;
				}
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					VerificationTimeoutInMs = input.ReadInt64();
					break;
				case 16u:
					StructureVerifier = (Types.Toggle)input.ReadEnum();
					break;
				}
			}
		}
	}
	public static class VersionsReflection
	{
		private static FileDescriptor descriptor;

		public static FileDescriptor Descriptor => descriptor;

		static VersionsReflection()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			descriptor = FileDescriptor.FromGeneratedCode(Convert.FromBase64String("Cid0ZW5zb3Jib2FyZC9jb21wYXQvcHJvdG8vdmVyc2lvbnMucHJvdG8SC3Rl" + "bnNvcmJvYXJkIksKClZlcnNpb25EZWYSEAoIcHJvZHVjZXIYASABKAUSFAoM" + "bWluX2NvbnN1bWVyGAIgASgFEhUKDWJhZF9jb25zdW1lcnMYAyADKAVCgAEK" + "GG9yZy50ZW5zb3JmbG93LmZyYW1ld29ya0IOVmVyc2lvbnNQcm90b3NQAVpP" + "Z2l0aHViLmNvbS90ZW5zb3JmbG93L3RlbnNvcmZsb3cvdGVuc29yZmxvdy9n" + "by9jb3JlL2ZyYW1ld29yay92ZXJzaW9uc19nb19wcm90b/gBAWIGcHJvdG8z"), (FileDescriptor[])(object)new FileDescriptor[0], new GeneratedClrTypeInfo((Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])(object)new GeneratedClrTypeInfo[1]
			{
				new GeneratedClrTypeInfo(typeof(VersionDef), (MessageParser)(object)VersionDef.Parser, new string[3] { "Producer", "MinConsumer", "BadConsumers" }, (string[])null, (Type[])null, (Extension[])null, (GeneratedClrTypeInfo[])null)
			}));
		}
	}
	public sealed class VersionDef : IMessage<VersionDef>, IMessage, IEquatable<VersionDef>, IDeepCloneable<VersionDef>
	{
		private static readonly MessageParser<VersionDef> _parser = new MessageParser<VersionDef>((Func<VersionDef>)(() => new VersionDef()));

		private UnknownFieldSet _unknownFields;

		public const int ProducerFieldNumber = 1;

		private int producer_;

		public const int MinConsumerFieldNumber = 2;

		private int minConsumer_;

		public const int BadConsumersFieldNumber = 3;

		private static readonly FieldCodec<int> _repeated_badConsumers_codec = FieldCodec.ForInt32(26u);

		private readonly RepeatedField<int> badConsumers_ = new RepeatedField<int>();

		[DebuggerNonUserCode]
		public static MessageParser<VersionDef> Parser => _parser;

		[DebuggerNonUserCode]
		public static MessageDescriptor Descriptor => VersionsReflection.Descriptor.MessageTypes[0];

		[DebuggerNonUserCode]
		MessageDescriptor IMessage.Descriptor => Descriptor;

		[DebuggerNonUserCode]
		public int Producer
		{
			get
			{
				return producer_;
			}
			set
			{
				producer_ = value;
			}
		}

		[DebuggerNonUserCode]
		public int MinConsumer
		{
			get
			{
				return minConsumer_;
			}
			set
			{
				minConsumer_ = value;
			}
		}

		[DebuggerNonUserCode]
		public RepeatedField<int> BadConsumers => badConsumers_;

		[DebuggerNonUserCode]
		public VersionDef()
		{
		}

		[DebuggerNonUserCode]
		public VersionDef(VersionDef other)
			: this()
		{
			producer_ = other.producer_;
			minConsumer_ = other.minConsumer_;
			badConsumers_ = other.badConsumers_.Clone();
			_unknownFields = UnknownFieldSet.Clone(other._unknownFields);
		}

		[DebuggerNonUserCode]
		public VersionDef Clone()
		{
			return new VersionDef(this);
		}

		[DebuggerNonUserCode]
		public override bool Equals(object other)
		{
			return Equals(other as VersionDef);
		}

		[DebuggerNonUserCode]
		public bool Equals(VersionDef other)
		{
			if (other == null)
			{
				return false;
			}
			if (other == this)
			{
				return true;
			}
			if (Producer != other.Producer)
			{
				return false;
			}
			if (MinConsumer != other.MinConsumer)
			{
				return false;
			}
			if (!badConsumers_.Equals(other.badConsumers_))
			{
				return false;
			}
			return object.Equals(_unknownFields, other._unknownFields);
		}

		[DebuggerNonUserCode]
		public override int GetHashCode()
		{
			int num = 1;
			if (Producer != 0)
			{
				num ^= Producer.GetHashCode();
			}
			if (MinConsumer != 0)
			{
				num ^= MinConsumer.GetHashCode();
			}
			num ^= ((object)badConsumers_).GetHashCode();
			if (_unknownFields != null)
			{
				num ^= ((object)_unknownFields).GetHashCode();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public override string ToString()
		{
			return JsonFormatter.ToDiagnosticString((IMessage)(object)this);
		}

		[DebuggerNonUserCode]
		public void WriteTo(CodedOutputStream output)
		{
			if (Producer != 0)
			{
				output.WriteRawTag((byte)8);
				output.WriteInt32(Producer);
			}
			if (MinConsumer != 0)
			{
				output.WriteRawTag((byte)16);
				output.WriteInt32(MinConsumer);
			}
			badConsumers_.WriteTo(output, _repeated_badConsumers_codec);
			if (_unknownFields != null)
			{
				_unknownFields.WriteTo(output);
			}
		}

		[DebuggerNonUserCode]
		public int CalculateSize()
		{
			int num = 0;
			if (Producer != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(Producer);
			}
			if (MinConsumer != 0)
			{
				num += 1 + CodedOutputStream.ComputeInt32Size(MinConsumer);
			}
			num += badConsumers_.CalculateSize(_repeated_badConsumers_codec);
			if (_unknownFields != null)
			{
				num += _unknownFields.CalculateSize();
			}
			return num;
		}

		[DebuggerNonUserCode]
		public void MergeFrom(VersionDef other)
		{
			if (other != null)
			{
				if (other.Producer != 0)
				{
					Producer = other.Producer;
				}
				if (other.MinConsumer != 0)
				{
					MinConsumer = other.MinConsumer;
				}
				badConsumers_.Add((IEnumerable<int>)other.badConsumers_);
				_unknownFields = UnknownFieldSet.MergeFrom(_unknownFields, other._unknownFields);
			}
		}

		[DebuggerNonUserCode]
		public void MergeFrom(CodedInputStream input)
		{
			uint num;
			while ((num = input.ReadTag()) != 0)
			{
				switch (num)
				{
				default:
					_unknownFields = UnknownFieldSet.MergeFieldFrom(_unknownFields, input);
					break;
				case 8u:
					Producer = input.ReadInt32();
					break;
				case 16u:
					MinConsumer = input.ReadInt32();
					break;
				case 24u:
				case 26u:
					badConsumers_.AddEntriesFrom(input, _repeated_badConsumers_codec);
					break;
				}
			}
		}
	}
}
namespace System
{
	internal static class NSExtension
	{
		public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source)
		{
			return source.ToHashSet(null);
		}

		public static HashSet<TSource> ToHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			return new HashSet<TSource>(source, comparer);
		}

		public static bool TryAdd<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key, TValue value)
		{
			if (!dictionary.TryGetValue(key, out var _))
			{
				dictionary.Add(key, value);
				return true;
			}
			return false;
		}

		public static bool Contains(this string source, char c)
		{
			if (!string.IsNullOrEmpty(source))
			{
				return source.IndexOf(c) >= 0;
			}
			return false;
		}

		public static bool EndsWith(this string source, char c)
		{
			if (!string.IsNullOrEmpty(source))
			{
				return source[source.Length - 1] == c;
			}
			return false;
		}

		public static bool StartsWith(this string source, char c)
		{
			if (!string.IsNullOrEmpty(source))
			{
				return source[0] == c;
			}
			return false;
		}
	}
	internal static class MathF
	{
		public const float PI = 3.1415927f;

		internal const float NegativeZero = -0f;

		private const string CrtLibrary = "ucrtbase.dll";

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Max(float x, float y)
		{
			return Math.Max(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Round(float x)
		{
			return (float)Math.Round(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sqrt(float x)
		{
			return (float)Math.Sqrt(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Sign(float x)
		{
			return Math.Sign(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Abs(float x)
		{
			return Math.Abs(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Log10(float x)
		{
			return log10f(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Log2(float x)
		{
			return log2f(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Acos(float x)
		{
			return acosf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Cos(float x)
		{
			return cosf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Cosh(float x)
		{
			return coshf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Atan(float x)
		{
			return atanf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Tanh(float x)
		{
			return tanhf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Pow(float x, float y)
		{
			return powf(x, y);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sin(float x)
		{
			return sinf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Sinh(float x)
		{
			return sinhf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Asinh(float x)
		{
			return asinhf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Tan(float x)
		{
			return tanf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Acosh(float x)
		{
			return acoshf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Atanh(float x)
		{
			return atanhf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Asin(float x)
		{
			return asinf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Log(float x)
		{
			return logf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Exp(float x)
		{
			return expf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Floor(float x)
		{
			return floorf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Ceiling(float x)
		{
			return ceilf(x);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Truncate(float x)
		{
			return truncf(x);
		}

		public static float Log(float x, float y)
		{
			if (float.IsNaN(x))
			{
				return x;
			}
			if (float.IsNaN(y))
			{
				return y;
			}
			if (y == 1f)
			{
				return float.NaN;
			}
			if (x != 1f && (y == 0f || float.IsPositiveInfinity(y)))
			{
				return float.NaN;
			}
			return Log(x) / Log(y);
		}

		public static float IEEERemainder(float x, float y)
		{
			if (float.IsNaN(x))
			{
				return x;
			}
			if (float.IsNaN(y))
			{
				return y;
			}
			float num = x % y;
			if (float.IsNaN(num))
			{
				return float.NaN;
			}
			if (num == 0f && IsNegative(x))
			{
				return -0f;
			}
			float num2 = num - Abs(y) * (float)Sign(x);
			if (Abs(num2) == Abs(num))
			{
				float x2 = x / y;
				if (Abs(Round(x2)) > Abs(x2))
				{
					return num2;
				}
				return num;
			}
			if (Abs(num2) < Abs(num))
			{
				return num2;
			}
			return num;
		}

		internal static bool IsNegative(float x)
		{
			return (BitConverter.DoubleToInt64Bits(x) & long.MinValue) == long.MinValue;
		}

		[DllImport("ucrtbase.dll")]
		private static extern float asinhf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float acosf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float cosf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float coshf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float atanf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float tanhf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float powf(float x, float y);

		[DllImport("ucrtbase.dll")]
		private static extern float sinf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float sinhf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float tanf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float logf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float acoshf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float atanhf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float asinf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float log10f(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float log2f(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float expf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float floorf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float ceilf(float x);

		[DllImport("ucrtbase.dll")]
		private static extern float truncf(float x);
	}
	internal static class NativeLibrary
	{
		internal struct LoadLibErrorTracker
		{
			internal const int ERROR_INVALID_PARAMETER = 87;

			internal const int ERROR_MOD_NOT_FOUND = 126;

			internal const int ERROR_BAD_EXE_FORMAT = 193;

			private int _errorCode;

			public void Throw(string libraryName)
			{
				if (_errorCode == 193)
				{
					throw new BadImageFormatException();
				}
				throw new DllNotFoundException("Unable to native library '" + libraryName + "' or one of its dependencies.");
			}

			public void TrackErrorCode(int errorCode)
			{
				_errorCode = errorCode;
			}
		}

		internal struct LibraryNameVariation
		{
			private const string LibraryNameSuffix = ".dll";

			public string Prefix;

			public string Suffix;

			public LibraryNameVariation(string prefix, string suffix)
			{
				Prefix = prefix;
				Suffix = suffix;
			}

			internal static IEnumerable<LibraryNameVariation> DetermineLibraryNameVariations(string libName, bool isRelativePath, bool forOSLoader = false)
			{
				yield return new LibraryNameVariation(string.Empty, string.Empty);
				if (isRelativePath && (!forOSLoader || (NSExtension.Contains(libName, '.') && !NSExtension.EndsWith(libName, '.'))) && !libName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase) && !libName.EndsWith(".exe", StringComparison.OrdinalIgnoreCase))
				{
					yield return new LibraryNameVariation(string.Empty, ".dll");
				}
			}
		}

		[DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
		internal static extern IntPtr LoadLibraryEx(string lpFileName, IntPtr hReservedNull, int dwFlags);

		public static bool TryLoad(string libraryPath, out IntPtr handle)
		{
			if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				throw new NotSupportedException("This call is not supported on non-Windows platforms.");
			}
			if (libraryPath == null)
			{
				throw new ArgumentNullException("libraryPath");
			}
			handle = LoadFromPath(libraryPath, throwOnError: false);
			return handle != IntPtr.Zero;
		}

		public static bool TryLoad(string libraryName, Assembly assembly, DllImportSearchPath? searchPath, out IntPtr handle)
		{
			if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
			{
				throw new NotSupportedException("This call is not supported on non-Windows platforms.");
			}
			if (libraryName == null)
			{
				throw new ArgumentNullException("libraryName");
			}
			if (assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			handle = LoadLibraryByName(libraryName, assembly, searchPath, throwOnError: false);
			return handle != IntPtr.Zero;
		}

		internal static IntPtr LoadLibraryByName(string libraryName, Assembly assembly, DllImportSearchPath? searchPath, bool throwOnError)
		{
			int searchPathFlags;
			bool searchAssemblyDirectory;
			if (searchPath.HasValue)
			{
				searchPathFlags = (int)(searchPath.Value & ~DllImportSearchPath.AssemblyDirectory);
				searchAssemblyDirectory = (searchPath.Value & DllImportSearchPath.AssemblyDirectory) != 0;
			}
			else
			{
				GetDllImportSearchPathFlags(assembly, out searchPathFlags, out searchAssemblyDirectory);
			}
			LoadLibErrorTracker errorTracker = default(LoadLibErrorTracker);
			IntPtr intPtr = LoadBySearch(assembly, searchAssemblyDirectory, searchPathFlags, ref errorTracker, libraryName);
			if (throwOnError && intPtr == IntPtr.Zero)
			{
				errorTracker.Throw(libraryName);
			}
			return intPtr;
		}

		internal static IntPtr LoadBySearch(Assembly callingAssembly, bool searchAssemblyDirectory, int dllImportSearchPathFlags, ref LoadLibErrorTracker errorTracker, string libraryName)
		{
			int num = 0;
			bool flag = !Path.IsPathRooted(libraryName);
			foreach (LibraryNameVariation item in LibraryNameVariation.DetermineLibraryNameVariations(libraryName, flag))
			{
				string libraryName2 = item.Prefix + libraryName + item.Suffix;
				IntPtr intPtr;
				if (!flag)
				{
					int num2 = num;
					if ((dllImportSearchPathFlags & 0x100) != 0)
					{
						num2 |= dllImportSearchPathFlags;
					}
					intPtr = LoadLibraryHelper(libraryName2, num2, ref errorTracker);
					if (intPtr != IntPtr.Zero)
					{
						return intPtr;
					}
				}
				else
				{
					_ = callingAssembly != null && searchAssemblyDirectory;
				}
				intPtr = LoadLibraryHelper(libraryName2, dllImportSearchPathFlags, ref errorTracker);
				if (intPtr != IntPtr.Zero)
				{
					return intPtr;
				}
			}
			return IntPtr.Zero;
		}

		internal static void GetDllImportSearchPathFlags(Assembly callingAssembly, out int searchPathFlags, out bool searchAssemblyDirectory)
		{
			DllImportSearchPath dllImportSearchPath = DllImportSearchPath.AssemblyDirectory;
			foreach (CustomAttributeData customAttribute in callingAssembly.CustomAttributes)
			{
				if (customAttribute.AttributeType == typeof(DefaultDllImportSearchPathsAttribute))
				{
					dllImportSearchPath = (DllImportSearchPath)customAttribute.ConstructorArguments[0].Value;
				}
			}
			searchPathFlags = (int)(dllImportSearchPath & ~DllImportSearchPath.AssemblyDirectory);
			searchAssemblyDirectory = (dllImportSearchPath & DllImportSearchPath.AssemblyDirectory) != 0;
		}

		private static IntPtr LoadFromPath(string libraryName, bool throwOnError)
		{
			LoadLibErrorTracker errorTracker = default(LoadLibErrorTracker);
			IntPtr intPtr = LoadLibraryHelper(libraryName, 0, ref errorTracker);
			if (throwOnError && intPtr == IntPtr.Zero)
			{
				errorTracker.Throw(libraryName);
			}
			return intPtr;
		}

		private static IntPtr LoadLibraryHelper(string libraryName, int flags, ref LoadLibErrorTracker errorTracker)
		{
			IntPtr intPtr = LoadLibraryEx(libraryName, IntPtr.Zero, flags);
			if (intPtr != IntPtr.Zero)
			{
				return intPtr;
			}
			int lastWin32Error = Marshal.GetLastWin32Error();
			if (lastWin32Error != 87)
			{
				errorTracker.TrackErrorCode(lastWin32Error);
			}
			return intPtr;
		}
	}
}
namespace System.IO
{
	internal class NSPath
	{
		internal const char DirectorySeparatorChar = '\\';

		internal const char AltDirectorySeparatorChar = '/';

		internal const string DirectorySeparatorCharAsString = "\\";

		public static string Join(string path1, string path2)
		{
			if (path1 == null || path1.Length == 0)
			{
				return path2;
			}
			if (path2 == null || path2.Length == 0)
			{
				return path1;
			}
			if (!IsDirectorySeparator(path1[path1.Length - 1]) && !IsDirectorySeparator(path2[0]))
			{
				return path1 + "\\" + path2;
			}
			return path1 + path2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsDirectorySeparator(char c)
		{
			if (c != '\\')
			{
				return c == '/';
			}
			return true;
		}

		public static string Join(string path1, string path2, string path3)
		{
			if (path1 == null || path1.Length == 0)
			{
				return Join(path2, path3);
			}
			if (path2 == null || path2.Length == 0)
			{
				return Join(path1, path3);
			}
			if (path3 == null || path3.Length == 0)
			{
				return Join(path1, path2);
			}
			bool flag = IsDirectorySeparator(path1[path1.Length - 1]) || IsDirectorySeparator(path2[0]);
			bool flag2 = IsDirectorySeparator(path2[path2.Length - 1]) || IsDirectorySeparator(path3[0]);
			return path1 + (flag ? "" : "\\") + path2 + (flag2 ? "" : "\\") + path3;
		}

		public static string Join(string path1, string path2, string path3, string path4)
		{
			if (path1 == null || path1.Length == 0)
			{
				return Join(path2, path3, path4);
			}
			if (path2 == null || path2.Length == 0)
			{
				return Join(path1, path3, path4);
			}
			if (path3 == null || path3.Length == 0)
			{
				return Join(path1, path2, path4);
			}
			if (path4 == null || path4.Length == 0)
			{
				return Join(path1, path2, path3);
			}
			bool flag = IsDirectorySeparator(path1[path1.Length - 1]) || IsDirectorySeparator(path2[0]);
			bool flag2 = IsDirectorySeparator(path2[path2.Length - 1]) || IsDirectorySeparator(path3[0]);
			bool flag3 = IsDirectorySeparator(path3[path3.Length - 1]) || IsDirectorySeparator(path4[0]);
			return path1 + (flag ? "" : "\\") + path2 + (flag2 ? "" : "\\") + path3 + (flag3 ? "" : "\\") + path4;
		}
	}
}
namespace System.Linq
{
	internal static class NSEnumerable
	{
		public static IEnumerable<TResult> Zip<TFirst, TSecond, TResult>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			if (resultSelector == null)
			{
				throw new ArgumentNullException("resultSelector");
			}
			return ZipIterator(first, second, resultSelector);
		}

		public static IEnumerable<(TFirst First, TSecond Second)> Zip<TFirst, TSecond>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			return ZipIterator(first, second);
		}

		public static IEnumerable<(TFirst First, TSecond Second, TThird Third)> Zip<TFirst, TSecond, TThird>(this IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third)
		{
			if (first == null)
			{
				throw new ArgumentNullException("first");
			}
			if (second == null)
			{
				throw new ArgumentNullException("second");
			}
			if (third == null)
			{
				throw new ArgumentNullException("third");
			}
			return ZipIterator(first, second, third);
		}

		private static IEnumerable<(TFirst First, TSecond Second)> ZipIterator<TFirst, TSecond>(IEnumerable<TFirst> first, IEnumerable<TSecond> second)
		{
			using IEnumerator<TFirst> e1 = first.GetEnumerator();
			using IEnumerator<TSecond> e2 = second.GetEnumerator();
			while (e1.MoveNext() && e2.MoveNext())
			{
				yield return (First: e1.Current, Second: e2.Current);
			}
		}

		private static IEnumerable<TResult> ZipIterator<TFirst, TSecond, TResult>(IEnumerable<TFirst> first, IEnumerable<TSecond> second, Func<TFirst, TSecond, TResult> resultSelector)
		{
			using IEnumerator<TFirst> e1 = first.GetEnumerator();
			using IEnumerator<TSecond> e2 = second.GetEnumerator();
			while (e1.MoveNext() && e2.MoveNext())
			{
				yield return resultSelector(e1.Current, e2.Current);
			}
		}

		private static IEnumerable<(TFirst First, TSecond Second, TThird Third)> ZipIterator<TFirst, TSecond, TThird>(IEnumerable<TFirst> first, IEnumerable<TSecond> second, IEnumerable<TThird> third)
		{
			using IEnumerator<TFirst> e1 = first.GetEnumerator();
			using IEnumerator<TSecond> e2 = second.GetEnumerator();
			using IEnumerator<TThird> e3 = third.GetEnumerator();
			while (e1.MoveNext() && e2.MoveNext() && e3.MoveNext())
			{
				yield return (First: e1.Current, Second: e2.Current, Third: e3.Current);
			}
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace TorchSharp
{
	internal class AutoGradMode : IDisposable
	{
		private readonly bool _isPrevGrad;

		public static bool IsEnabled => NativeMethods.THSAutograd_isGradEnabled();

		public AutoGradMode(bool enabled)
		{
			_isPrevGrad = NativeMethods.THSAutograd_isGradEnabled();
			NativeMethods.THSAutograd_setGrad(enabled);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public void Dispose(bool disposing)
		{
			if (disposing)
			{
				NativeMethods.THSAutograd_setGrad(_isPrevGrad);
			}
		}
	}
	internal class InferenceMode : IDisposable
	{
		private IntPtr _guard;

		public static bool IsEnabled => NativeMethods.THSAutograd_isInferenceModeEnabled();

		public InferenceMode(bool mode)
		{
			_guard = NativeMethods.THSAutograd_getInferenceModeGuard(mode);
		}

		~InferenceMode()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		public void Dispose(bool disposing)
		{
			if (_guard != IntPtr.Zero)
			{
				NativeMethods.THSAutograd_deleteInferenceModeGuard(_guard);
				_guard = IntPtr.Zero;
			}
		}
	}
	public class AnomalyMode : IDisposable
	{
		private readonly bool _isPrevGrad;

		private readonly bool _shouldCheckNaN;

		public static bool IsEnabled => NativeMethods.THSAutograd_isAnomalyEnabled();

		public static bool ShouldCheckNaN => NativeMethods.THSAutograd_shouldCheckNaN();

		public AnomalyMode(bool enabled, bool check_nan = true)
		{
			_isPrevGrad = NativeMethods.THSAutograd_isAnomalyEnabled();
			_shouldCheckNaN = NativeMethods.THSAutograd_shouldCheckNaN();
			NativeMethods.THSAutograd_setAnomaly(enabled, check_nan);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				NativeMethods.THSAutograd_setAnomaly(_isPrevGrad, _shouldCheckNaN);
			}
		}
	}
	public static class torch
	{
		public static class autograd
		{
			internal class SavedVariable : IDisposable
			{
				private IntPtr _handle;

				private bool _emptyConstructor;

				internal SavedVariable(Tensor tensor, NativeMethods.NodeUnmanagedPtr nodeHandle, bool is_inplace_on_view = false)
				{
					_handle = NativeMethods.THSAutograd_SavedVariable_ctor(tensor.Handle, nodeHandle, is_inplace_on_view);
					CheckForErrors();
				}

				internal SavedVariable()
				{
					_handle = IntPtr.Zero;
					_emptyConstructor = true;
				}

				public Tensor unpack(Node saved_for = null)
				{
					if (_emptyConstructor)
					{
						return null;
					}
					IntPtr handle = NativeMethods.THSAutograd_SavedVariable_unpack(_handle, saved_for?.handle ?? default(NativeMethods.NodeUnmanagedPtr));
					CheckForErrors();
					return new Tensor(handle);
				}

				public void reset_data()
				{
					if (!_emptyConstructor)
					{
						NativeMethods.THSAutograd_SavedVariable_reset_data(_handle);
						CheckForErrors();
					}
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				public void Dispose(bool disposing)
				{
					if (_handle != IntPtr.Zero)
					{
						NativeMethods.THSAutograd_SavedVariable_dispose(_handle);
						CheckForErrors();
						_handle = IntPtr.Zero;
					}
				}

				~SavedVariable()
				{
					Dispose(disposing: false);
				}
			}

			internal abstract class Node
			{
				public NativeMethods.NodeUnmanagedPtr handle;

				private static List<Node> AliveNodes = new List<Node>();

				protected static void AddNode(Node node)
				{
					lock (AliveNodes)
					{
						AliveNodes.Add(node);
					}
				}

				protected static void DeleteNode(Node node)
				{
					lock (AliveNodes)
					{
						AliveNodes.Remove(node);
					}
				}
			}

			internal class Node<T> : Node, IDisposable where T : Function<T>, new()
			{
				private NativeMethods.ApplyFunc _applyFuncRef;

				private NativeMethods.ManagedDeleteNode _managedDeleteNode;

				private AutogradContext _context;

				private List<bool> _isVariableInput;

				private List<Tensor> _outputCache;

				private object _mutex;

				private bool _disposedSharedPtr;

				private PinnedArray<IntPtr> _applyFuncReturnArray;

				internal AutogradContext Context => _context;

				internal Node()
				{
					_applyFuncRef = ApplyFunc;
					_managedDeleteNode = DeleteNode;
					handle = NativeMethods.THSAutograd_CSharpNode_ctor(_applyFuncRef, _managedDeleteNode);
					CheckForErrors();
					Node.AddNode(this);
					_applyFuncReturnArray = new PinnedArray<IntPtr>();
					_isVariableInput = new List<bool>();
					_context = new AutogradContext(this);
					_mutex = new object();
				}

				internal List<Tensor> ComputeVariableInput(object[] args)
				{
					_isVariableInput.Clear();
					List<Tensor> list = new List<Tensor>();
					for (int i = 0; i < args.Length; i++)
					{
						if (args[i] is Tensor { IsInvalid: false } tensor)
						{
							list.Add(tensor);
							_isVariableInput.Add(item: true);
						}
						else
						{
							_isVariableInput.Add(item: false);
						}
					}
					return list;
				}

				internal void SetNextEdges(List<Tensor> inputVars, bool isExecutable)
				{
					using PinnedArray<IntPtr> arr = new PinnedArray<IntPtr>();
					NativeMethods.THSAutograd_CSharpNode_setNextEdges(handle, arr.CreateArrayWithSize(inputVars.ToHandleArray()), isExecutable);
					CheckForErrors();
				}

				internal void ClearInputMetadata()
				{
					NativeMethods.THSAutograd_CSharpNode_clearInputMetadata(handle);
					CheckForErrors();
				}

				internal List<Tensor> WrapOutputs(List<Tensor> inputVars, List<Tensor> outputs, bool isExecutable)
				{
					using PinnedArray<IntPtr> arr = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> arr2 = new PinnedArray<IntPtr>();
					using (new PinnedArray<IntPtr>())
					{
						using PinnedArray<IntPtr> arr3 = new PinnedArray<IntPtr>();
						using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
						NativeMethods.ArrayWithSize vars = arr.CreateArrayWithSize(inputVars.ToHandleArray());
						NativeMethods.ArrayWithSize nonDiff = arr2.CreateArrayWithSize(_context.NonDifferentiableTensors.ToHandleArray());
						NativeMethods.ArrayWithSize dirty = arr2.CreateArrayWithSize(_context.DirtyTensors.ToHandleArray());
						NativeMethods.ArrayWithSize outputs2 = arr3.CreateArrayWithSize(outputs.ToHandleArray());
						NativeMethods.THSAutograd_Function_wrapOutputs(vars, nonDiff, dirty, outputs2, isExecutable ? handle : default(NativeMethods.NodeUnmanagedPtr), pinnedArray.CreateArray);
						CheckForErrors();
						List<Tensor> list = pinnedArray.Array.Select((IntPtr x) => new Tensor(x)).ToList();
						SaveOutputsInfo(list, isExecutable);
						return list;
					}
				}

				internal void SaveOutputsInfo(List<Tensor> outputs, bool isExecutable)
				{
					_outputCache = new List<Tensor>();
					foreach (Tensor output in outputs)
					{
						if (isExecutable && !output.IsInvalid)
						{
							_outputCache.Add(empty_like(output));
						}
						else if (isExecutable)
						{
							_outputCache.Add(null);
						}
					}
				}

				internal void save_variables_to_ctx()
				{
					_context.save_variables();
				}

				private NativeMethods.ArrayWithSize ApplyFunc(IntPtr[] tensors, int size)
				{
					lock (_mutex)
					{
						List<Tensor> list = new List<Tensor>();
						for (int i = 0; i < tensors.Length; i++)
						{
							if (!_context.MaterializeGrads || tensors[i] != IntPtr.Zero || (object)_outputCache[i] == null)
							{
								list.Add(new Tensor(tensors[i]));
							}
							else
							{
								list.Add(zeros_like(_outputCache[i]));
							}
						}
						List<Tensor> list2 = Function<T>.Instance.backward_internal(_context, list);
						if (list2.Count > _isVariableInput.Count && list2.Skip(_isVariableInput.Count).All((Tensor t) => t?.IsInvalid ?? true))
						{
							list2 = list2.GetRange(0, _isVariableInput.Count);
						}
						if (list2.Count != _isVariableInput.Count)
						{
							throw new NotImplementedException($"Function {Function<T>.Instance.Name} returned an incorrect number of gradients (expected {_isVariableInput.Count}), got {list2.Count}");
						}
						List<Tensor> list3 = new List<Tensor>();
						for (int num = 0; num < list2.Count; num++)
						{
							if (!_isVariableInput[num])
							{
								if ((object)list2[num] != null && !list2[num].IsInvalid)
								{
									throw new NotImplementedException($"Function {Function<T>.Instance.Name} returned a gradient different that is defined at position {num + 1}, but the corresponding forward input was not a Tensor");
								}
							}
							else
							{
								list3.Add(list2[num]);
							}
						}
						return _applyFuncReturnArray.CreateArrayWithSize(list3.Select((Tensor p) => p?.handle ?? IntPtr.Zero).ToArray());
					}
				}

				private void DeleteNode()
				{
					Node.DeleteNode(this);
					Dispose();
				}

				public void DisposeSharedPtr()
				{
					lock (_mutex)
					{
						if (!_disposedSharedPtr)
						{
							_disposedSharedPtr = true;
							NativeMethods.THSAutograd_CSharpNode_disposeSharedPtr(handle);
							try
							{
								CheckForErrors();
							}
							catch
							{
								_disposedSharedPtr = false;
								throw;
							}
							handle.sharedPtr = IntPtr.Zero;
						}
					}
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				public void Dispose(bool disposing)
				{
					if (handle.sharedPtr != IntPtr.Zero)
					{
						DisposeSharedPtr();
					}
					if (handle.weakPtr != IntPtr.Zero)
					{
						NativeMethods.THSAutograd_CSharpNode_disposeWeakPtr(handle);
						CheckForErrors();
						handle.weakPtr = IntPtr.Zero;
					}
					if (disposing)
					{
						_context?.Dispose();
						_context = null;
						_applyFuncReturnArray?.Dispose();
						_applyFuncReturnArray = null;
						_outputCache?.ForEach(delegate(Tensor t)
						{
							t?.Dispose();
						});
						_outputCache = null;
					}
				}

				~Node()
				{
					Dispose(disposing: false);
				}
			}

			public class AutogradContext : IDisposable
			{
				private Node _node;

				private bool _materializeGrads = true;

				private List<Tensor> _tensorsToSave = new List<Tensor>();

				private List<Tensor> _dirtyTensors = new List<Tensor>();

				private List<Tensor> _nonDifferentiableTensors = new List<Tensor>();

				private List<SavedVariable> _savedVariables = new List<SavedVariable>();

				private Dictionary<string, object> _savedData = new Dictionary<string, object>();

				public bool MaterializeGrads => _materializeGrads;

				internal List<Tensor> DirtyTensors => _dirtyTensors;

				internal List<Tensor> NonDifferentiableTensors => _nonDifferentiableTensors;

				internal AutogradContext(Node node)
				{
					_node = node;
				}

				public void save_for_backward(List<Tensor> tensors)
				{
					_tensorsToSave = tensors;
				}

				public void save_data(string key, object value)
				{
					if (value is Tensor)
					{
						Console.WriteLine("Attempted to save a tensor object in the data object. Please store tensors by calling `save_for_backward()`");
					}
					_savedData[key] = value;
				}

				public void mark_dirty(List<Tensor> tensors)
				{
					_dirtyTensors = tensors.ToList();
				}

				public void mark_non_differentiable(List<Tensor> tensors)
				{
					_nonDifferentiableTensors = tensors.ToList();
				}

				public void set_materialize_grads(bool value)
				{
					_materializeGrads = value;
				}

				public List<Tensor> get_saved_variables()
				{
					lock (_node)
					{
						return _savedVariables.Select((SavedVariable v) => v.unpack(_node)).ToList();
					}
				}

				public object get_data(string key)
				{
					if (!_savedData.TryGetValue(key, out var value))
					{
						return null;
					}
					return value;
				}

				internal void save_variables()
				{
					_savedVariables.Clear();
					lock (_node)
					{
						foreach (Tensor item in _tensorsToSave)
						{
							_savedVariables.Add(((object)item == null || item.IsInvalid) ? new SavedVariable() : new SavedVariable(item, _node.handle));
						}
					}
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				protected virtual void Dispose(bool disposing)
				{
					if (disposing)
					{
						_savedVariables?.ForEach(delegate(SavedVariable v)
						{
							v.Dispose();
						});
						_savedVariables = null;
					}
				}
			}

			public abstract class Function<T> where T : Function<T>, new()
			{
				internal static T Instance { get; set; } = new T();

				public abstract string Name { get; }

				public static List<Tensor> apply_internal(params object[] vars)
				{
					Node<T> node = new Node<T>();
					List<Tensor> list = node.ComputeVariableInput(vars);
					bool flag = AutoGradMode.IsEnabled && list.Any((Tensor v) => v.requires_grad);
					node.SetNextEdges(list, flag);
					node.ClearInputMetadata();
					List<Tensor> outputs;
					using (new AutoGradMode(enabled: false))
					{
						outputs = Instance.forward_internal(node.Context, vars);
					}
					outputs = node.WrapOutputs(list, outputs, flag);
					if (flag)
					{
						node.save_variables_to_ctx();
					}
					node.DisposeSharedPtr();
					return outputs;
				}

				internal abstract List<Tensor> forward_internal(AutogradContext ctx, params object[] vars);

				internal abstract List<Tensor> backward_internal(AutogradContext ctx, List<Tensor> grad_outputs);
			}

			public abstract class SingleTensorFunction<T> : Function<T> where T : SingleTensorFunction<T>, new()
			{
				public static Tensor apply(params object[] vars)
				{
					return Function<T>.apply_internal(vars)[0];
				}

				internal sealed override List<Tensor> forward_internal(AutogradContext ctx, params object[] vars)
				{
					return new List<Tensor> { forward(ctx, vars) };
				}

				internal sealed override List<Tensor> backward_internal(AutogradContext ctx, List<Tensor> grad_outputs)
				{
					return backward(ctx, grad_outputs[0]);
				}

				public abstract Tensor forward(AutogradContext ctx, params object[] vars);

				public abstract List<Tensor> backward(AutogradContext ctx, Tensor grad_output);
			}

			public abstract class MultiTensorFunction<T> : Function<T> where T : MultiTensorFunction<T>, new()
			{
				public static List<Tensor> apply(params object[] vars)
				{
					return Function<T>.apply_internal(vars);
				}

				internal sealed override List<Tensor> forward_internal(AutogradContext ctx, params object[] vars)
				{
					return forward(ctx, vars);
				}

				internal sealed override List<Tensor> backward_internal(AutogradContext ctx, List<Tensor> grad_outputs)
				{
					return backward(ctx, grad_outputs);
				}

				public abstract List<Tensor> forward(AutogradContext ctx, params object[] vars);

				public abstract List<Tensor> backward(AutogradContext ctx, List<Tensor> grad_outputs);
			}

			public static class functional
			{
				private static Tensor[] _grad_preprocess(bool need_graph = true, params Tensor[] inputs)
				{
					List<Tensor> list = new List<Tensor>();
					foreach (Tensor tensor in inputs)
					{
						list.Add(tensor.detach().requires_grad_(need_graph));
					}
					return list.ToArray();
				}

				private static IEnumerable<Tensor> _autograd_grad(Tensor output, bool retain_graph = false, params Tensor[] inputs)
				{
					List<Tensor> outputs = new List<Tensor> { output };
					List<Tensor> inputs2 = new List<Tensor>(inputs);
					return grad(outputs, inputs2, null, retain_graph, create_graph: false, allow_unused: true);
				}

				public static IEnumerable<Tensor> jacobian(Func<Tensor[], Tensor[]> function, params Tensor[] inputs)
				{
					List<Tensor> list = new List<Tensor>();
					using (NewDisposeScope())
					{
						using (enable_grad())
						{
							inputs = _grad_preprocess(need_graph: true, inputs);
							Tensor[] array = function(inputs);
							for (int i = 0; i < array.Length; i++)
							{
								List<Tensor>[] array2 = new List<Tensor>[inputs.Length];
								for (int j = 0; j < inputs.Length; j++)
								{
									array2[j] = new List<Tensor>();
								}
								for (int k = 0; k < array[i].NumberOfElements; k++)
								{
									IEnumerable<Tensor> second = _autograd_grad(array[i].reshape(-1L)[k], retain_graph: true, inputs);
									foreach (var item in NSEnumerable.Zip(array2, second, inputs))
									{
										if (item.Second.IsInvalid)
										{
											item.First.Add(zeros_like(item.Third));
										}
										else
										{
											item.First.Add(item.Second);
										}
									}
								}
								foreach (var item2 in NSEnumerable.Zip(array2, inputs))
								{
									list.Add(stack(item2.First, 0L).view(array[i].size().Concat(item2.Second.size()).ToArray()).MoveToOuterDisposeScope());
								}
							}
						}
						return list;
					}
				}

				public static Tensor jacobian(Func<Tensor, Tensor> function, Tensor inputs)
				{
					return jacobian((Tensor[] x) => new Tensor[1] { function(x.Single()) }, inputs).Single();
				}

				public static IEnumerable<Tensor> jacobian(Func<Tensor, Tensor[]> function, Tensor inputs)
				{
					return jacobian((Tensor[] x) => function(x.Single()), inputs);
				}

				public static IEnumerable<Tensor> jacobian(Func<Tensor[], Tensor> function, params Tensor[] inputs)
				{
					return jacobian((Tensor[] x) => new Tensor[1] { function(x) }, inputs);
				}
			}

			public static IList<Tensor> grad(IList<Tensor> outputs, IList<Tensor> inputs, IList<Tensor> grad_outputs = null, bool retain_graph = false, bool create_graph = false, bool allow_unused = false)
			{
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
				using PinnedArray<IntPtr> pinnedArray3 = new PinnedArray<IntPtr>();
				using PinnedArray<IntPtr> pinnedArray4 = new PinnedArray<IntPtr>();
				NativeMethods.THSAutograd_grad(pinnedArray.CreateArray(outputs.ToHandleArray()), inputs: pinnedArray2.CreateArray(inputs.ToHandleArray()), grad_outs: (grad_outputs == null) ? IntPtr.Zero : pinnedArray3.CreateArray(grad_outputs.ToHandleArray()), gLength: (grad_outputs != null) ? pinnedArray3.Array.Length : 0, oLength: pinnedArray.Array.Length, iLength: pinnedArray2.Array.Length, retain_graph: retain_graph, create_graph: create_graph, allow_unused: allow_unused, allocator: pinnedArray4.CreateArray);
				CheckForErrors();
				return pinnedArray4.Array.Select((IntPtr x) => new Tensor(x)).ToList();
			}

			public static void backward(IList<Tensor> tensors, IList<Tensor> grad_tensors = null, bool? retain_graph = null, bool create_graph = false, IList<Tensor> inputs = null)
			{
				bool retain_graph2 = retain_graph ?? create_graph;
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
				using PinnedArray<IntPtr> pinnedArray3 = new PinnedArray<IntPtr>();
				NativeMethods.THSAutograd_backward(pinnedArray.CreateArray(tensors.ToHandleArray()), grad_tensors: (grad_tensors == null) ? IntPtr.Zero : pinnedArray2.CreateArray(grad_tensors.ToHandleArray()), inputs: (inputs == null) ? IntPtr.Zero : pinnedArray3.CreateArray(inputs.ToHandleArray()), iLength: (inputs != null) ? pinnedArray3.Array.Length : 0, gtLength: (grad_tensors != null) ? pinnedArray2.Array.Length : 0, tLength: pinnedArray.Array.Length, retain_graph: retain_graph2, create_graph: create_graph);
				CheckForErrors();
			}

			public static void backward(Tensor tensor, IList<Tensor> grad_tensors = null, bool? retain_graph = null, bool create_graph = false, IList<Tensor> inputs = null)
			{
				backward(new Tensor[1] { tensor }, grad_tensors, retain_graph, create_graph, inputs);
			}

			public static void backward(Tensor tensor, Tensor grad_tensor, bool? retain_graph = null, bool create_graph = false, IList<Tensor> inputs = null)
			{
				backward(new Tensor[1] { tensor }, new Tensor[1] { grad_tensor }, retain_graph, create_graph, inputs);
			}

			public static AnomalyMode detect_anomaly(bool check_nan = true)
			{
				return new AnomalyMode(enabled: true, check_nan);
			}

			public static AnomalyMode set_detect_anomaly(bool mode, bool check_nan = true)
			{
				return new AnomalyMode(mode, check_nan);
			}
		}

		public static class utils
		{
			public static class data
			{
				public abstract class Dataset : Dataset<Dictionary<string, Tensor>>
				{
				}

				public abstract class IterableDataset : Dataset<IList<Tensor>>
				{
				}

				public abstract class Dataset<T> : IDisposable
				{
					public abstract long Count { get; }

					public void Dispose()
					{
						Dispose(disposing: true);
						GC.SuppressFinalize(this);
					}

					public abstract T GetTensor(long index);

					protected virtual void Dispose(bool disposing)
					{
					}
				}

				public static DataLoader DataLoader(Dataset dataset, int batchSize, IEnumerable<long> shuffler, Device device = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
				{
					return new DataLoader(dataset, batchSize, shuffler, device, num_worker, drop_last, disposeBatch, disposeDataset);
				}

				public static DataLoader DataLoader(Dataset dataset, int batchSize, bool shuffle = false, Device device = null, int? seed = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
				{
					return new DataLoader(dataset, batchSize, shuffle, device, seed, num_worker, drop_last, disposeBatch, disposeDataset);
				}

				public static IterableDataLoader DataLoader(IterableDataset dataset, int batchSize, IEnumerable<long> shuffler, Device device = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
				{
					return new IterableDataLoader(dataset, batchSize, shuffler, device, num_worker, drop_last, disposeBatch, disposeDataset);
				}

				public static IterableDataLoader DataLoader(IterableDataset dataset, int batchSize, bool shuffle = false, Device device = null, int? seed = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
				{
					return new IterableDataLoader(dataset, batchSize, shuffle, device, seed, num_worker, drop_last, disposeBatch, disposeDataset);
				}

				public static TensorDataset TensorDataset(params Tensor[] tensors)
				{
					return new TensorDataset(tensors);
				}
			}

			public static class tensorboard
			{
				internal static class GifEncoder
				{
					internal class Encoder : IDisposable
					{
						protected int width;

						protected int height;

						protected SKColor transparent = SKColor.Empty;

						protected int transIndex;

						protected int repeat = -1;

						protected int delay;

						protected bool started;

						protected MemoryStream ms;

						protected SKBitmap image;

						protected byte[] pixels;

						protected byte[] indexedPixels;

						protected int colorDepth;

						protected byte[] colorTab;

						protected bool[] usedEntry = new bool[256];

						protected int palSize = 7;

						protected int dispose = -1;

						protected bool closeStream;

						protected bool firstFrame = true;

						protected bool sizeSet;

						protected int sample = 10;

						private bool disposedValue;

						public void SetDelay(int ms)
						{
							delay = (int)Math.Round((float)ms / 10f);
						}

						public void SetDispose(int code)
						{
							if (code >= 0)
							{
								dispose = code;
							}
						}

						public void SetRepeat(int iter)
						{
							if (iter >= 0)
							{
								repeat = iter;
							}
						}

						public void SetTransparent(SKColor c)
						{
							//IL_0001: Unknown result type (might be due to invalid IL or missing references)
							//IL_0002: Unknown result type (might be due to invalid IL or missing references)
							transparent = c;
						}

						public bool AddFrame(SKBitmap im)
						{
							if (im == null || !started)
							{
								return false;
							}
							bool result = true;
							try
							{
								if (!sizeSet)
								{
									SetSize(im.Width, im.Height);
								}
								image = im;
								GetImagePixels();
								AnalyzePixels();
								if (firstFrame)
								{
									WriteLSD();
									WritePalette();
									if (repeat >= 0)
									{
										WriteNetscapeExt();
									}
								}
								WriteGraphicCtrlExt();
								WriteImageDesc();
								if (!firstFrame)
								{
									WritePalette();
								}
								WritePixels();
								firstFrame = false;
							}
							catch (IOException)
							{
								result = false;
							}
							return result;
						}

						public bool Finish()
						{
							if (!started)
							{
								return false;
							}
							bool result = true;
							started = false;
							try
							{
								ms.WriteByte(59);
								ms.Flush();
							}
							catch (IOException)
							{
								result = false;
							}
							transIndex = 0;
							image = null;
							pixels = null;
							indexedPixels = null;
							colorTab = null;
							closeStream = false;
							firstFrame = true;
							return result;
						}

						public void SetFrameRate(float fps)
						{
							if (fps != 0f)
							{
								delay = (int)Math.Round(100f / fps);
							}
						}

						public void SetSize(int w, int h)
						{
							if (!started || firstFrame)
							{
								width = w;
								height = h;
								if (width < 1)
								{
									width = 320;
								}
								if (height < 1)
								{
									height = 240;
								}
								sizeSet = true;
							}
						}

						public bool Start(MemoryStream os)
						{
							if (os == null)
							{
								return false;
							}
							bool flag = true;
							closeStream = false;
							ms = os;
							try
							{
								WriteString("GIF89a");
							}
							catch (IOException)
							{
								flag = false;
							}
							return started = flag;
						}

						public bool Start()
						{
							bool flag;
							try
							{
								flag = Start(new MemoryStream(10240));
								closeStream = true;
							}
							catch (IOException)
							{
								flag = false;
							}
							return started = flag;
						}

						public bool Output(string file)
						{
							try
							{
								FileStream fileStream = new FileStream(file, FileMode.OpenOrCreate, FileAccess.Write, FileShare.None);
								fileStream.Write(ms.ToArray(), 0, (int)ms.Length);
								fileStream.Close();
							}
							catch (IOException)
							{
								return false;
							}
							return true;
						}

						public MemoryStream Output()
						{
							return ms;
						}

						protected void AnalyzePixels()
						{
							//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
							//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
							int num = pixels.Length;
							int num2 = num / 3;
							indexedPixels = new byte[num2];
							NeuQuant neuQuant = new NeuQuant(pixels, num, sample);
							colorTab = neuQuant.Process();
							int num3 = 0;
							for (int i = 0; i < num2; i++)
							{
								int num4 = neuQuant.Map(pixels[num3++] & 0xFF, pixels[num3++] & 0xFF, pixels[num3++] & 0xFF);
								usedEntry[num4] = true;
								indexedPixels[i] = (byte)num4;
							}
							pixels = null;
							colorDepth = 8;
							palSize = 7;
							if (transparent != SKColor.Empty)
							{
								transIndex = neuQuant.Map(((SKColor)(ref transparent)).Blue, ((SKColor)(ref transparent)).Green, ((SKColor)(ref transparent)).Red);
							}
						}

						protected int FindClosest(SKColor c)
						{
							if (colorTab == null)
							{
								return -1;
							}
							int red = ((SKColor)(ref c)).Red;
							int green = ((SKColor)(ref c)).Green;
							int blue = ((SKColor)(ref c)).Blue;
							int result = 0;
							int num = 16777216;
							int num2 = colorTab.Length;
							for (int i = 0; i < num2; i++)
							{
								int num3 = red - (colorTab[i++] & 0xFF);
								int num4 = green - (colorTab[i++] & 0xFF);
								int num5 = blue - (colorTab[i] & 0xFF);
								int num6 = num3 * num3 + num4 * num4 + num5 * num5;
								int num7 = i / 3;
								if (usedEntry[num7] && num6 < num)
								{
									num = num6;
									result = num7;
								}
							}
							return result;
						}

						protected void GetImagePixels()
						{
							//IL_0036: Unknown result type (might be due to invalid IL or missing references)
							//IL_003b: Unknown result type (might be due to invalid IL or missing references)
							pixels = new byte[3 * image.Width * image.Height];
							int num = 0;
							for (int i = 0; i < image.Height; i++)
							{
								for (int j = 0; j < image.Width; j++)
								{
									SKColor pixel = image.GetPixel(j, i);
									pixels[num] = ((SKColor)(ref pixel)).Red;
									num++;
									pixels[num] = ((SKColor)(ref pixel)).Green;
									num++;
									pixels[num] = ((SKColor)(ref pixel)).Blue;
									num++;
								}
							}
						}

						protected void WriteGraphicCtrlExt()
						{
							//IL_002a: Unknown result type (might be due to invalid IL or missing references)
							//IL_002f: Unknown result type (might be due to invalid IL or missing references)
							ms.WriteByte(33);
							ms.WriteByte(249);
							ms.WriteByte(4);
							int num;
							int num2;
							if (transparent == SKColor.Empty)
							{
								num = 0;
								num2 = 0;
							}
							else
							{
								num = 1;
								num2 = 2;
							}
							if (dispose >= 0)
							{
								num2 = dispose & 7;
							}
							num2 <<= 2;
							ms.WriteByte(Convert.ToByte(0 | num2 | 0 | num));
							WriteShort(delay);
							ms.WriteByte(Convert.ToByte(transIndex));
							ms.WriteByte(0);
						}

						protected void WriteImageDesc()
						{
							ms.WriteByte(44);
							WriteShort(0);
							WriteShort(0);
							WriteShort(width);
							WriteShort(height);
							if (firstFrame)
							{
								ms.WriteByte(0);
							}
							else
							{
								ms.WriteByte(Convert.ToByte(0x80 | palSize));
							}
						}

						protected void WriteLSD()
						{
							WriteShort(width);
							WriteShort(height);
							ms.WriteByte(Convert.ToByte(0xF0 | palSize));
							ms.WriteByte(0);
							ms.WriteByte(0);
						}

						protected void WriteNetscapeExt()
						{
							ms.WriteByte(33);
							ms.WriteByte(byte.MaxValue);
							ms.WriteByte(11);
							WriteString("NETSCAPE2.0");
							ms.WriteByte(3);
							ms.WriteByte(1);
							WriteShort(repeat);
							ms.WriteByte(0);
						}

						protected void WritePalette()
						{
							ms.Write(colorTab, 0, colorTab.Length);
							int num = 768 - colorTab.Length;
							for (int i = 0; i < num; i++)
							{
								ms.WriteByte(0);
							}
						}

						protected void WritePixels()
						{
							new LZWEncoder(indexedPixels, colorDepth).Encode(ms);
						}

						protected void WriteShort(int value)
						{
							ms.WriteByte(Convert.ToByte(value & 0xFF));
							ms.WriteByte(Convert.ToByte((value >> 8) & 0xFF));
						}

						protected void WriteString(string s)
						{
							char[] array = s.ToCharArray();
							for (int i = 0; i < array.Length; i++)
							{
								ms.WriteByte((byte)array[i]);
							}
						}

						protected virtual void Dispose(bool disposing)
						{
							if (!disposedValue)
							{
								if (disposing)
								{
									ms.Dispose();
								}
								disposedValue = true;
							}
						}

						~Encoder()
						{
							Dispose(disposing: false);
						}

						public void Dispose()
						{
							Dispose(disposing: true);
							GC.SuppressFinalize(this);
						}
					}

					internal class LZWEncoder
					{
						private static readonly int EOF = -1;

						private byte[] pixAry;

						private int initCodeSize;

						private int curPixel;

						private static readonly int BITS = 12;

						private static readonly int HSIZE = 5003;

						private int n_bits;

						private int maxbits = BITS;

						private int maxcode;

						private int maxmaxcode = 1 << BITS;

						private int[] htab = new int[HSIZE];

						private int[] codetab = new int[HSIZE];

						private int hsize = HSIZE;

						private int free_ent;

						private bool clear_flg;

						private int g_init_bits;

						private int ClearCode;

						private int EOFCode;

						private int cur_accum;

						private int cur_bits;

						private int[] masks = new int[17]
						{
							0, 1, 3, 7, 15, 31, 63, 127, 255, 511,
							1023, 2047, 4095, 8191, 16383, 32767, 65535
						};

						private int a_count;

						private byte[] accum = new byte[256];

						public LZWEncoder(byte[] pixels, int color_depth)
						{
							pixAry = pixels;
							initCodeSize = Math.Max(2, color_depth);
						}

						private void Add(byte c, Stream outs)
						{
							accum[a_count++] = c;
							if (a_count >= 254)
							{
								Flush(outs);
							}
						}

						private void ClearTable(Stream outs)
						{
							ResetCodeTable(hsize);
							free_ent = ClearCode + 2;
							clear_flg = true;
							Output(ClearCode, outs);
						}

						private void ResetCodeTable(int hsize)
						{
							for (int i = 0; i < hsize; i++)
							{
								htab[i] = -1;
							}
						}

						private void Compress(int init_bits, Stream outs)
						{
							g_init_bits = init_bits;
							clear_flg = false;
							n_bits = g_init_bits;
							maxcode = MaxCode(n_bits);
							ClearCode = 1 << init_bits - 1;
							EOFCode = ClearCode + 1;
							free_ent = ClearCode + 2;
							a_count = 0;
							int num = NextPixel();
							int num2 = 0;
							for (int num3 = hsize; num3 < 65536; num3 *= 2)
							{
								num2++;
							}
							num2 = 8 - num2;
							int num4 = hsize;
							ResetCodeTable(num4);
							Output(ClearCode, outs);
							int num5;
							while ((num5 = NextPixel()) != EOF)
							{
								int num3 = (num5 << maxbits) + num;
								int num6 = (num5 << num2) ^ num;
								if (htab[num6] == num3)
								{
									num = codetab[num6];
									continue;
								}
								if (htab[num6] >= 0)
								{
									int num7 = num4 - num6;
									if (num6 == 0)
									{
										num7 = 1;
									}
									while (true)
									{
										if ((num6 -= num7) < 0)
										{
											num6 += num4;
										}
										if (htab[num6] == num3)
										{
											break;
										}
										if (htab[num6] >= 0)
										{
											continue;
										}
										goto IL_0121;
									}
									num = codetab[num6];
									continue;
								}
								goto IL_0121;
								IL_0121:
								Output(num, outs);
								num = num5;
								if (free_ent < maxmaxcode)
								{
									codetab[num6] = free_ent++;
									htab[num6] = num3;
								}
								else
								{
									ClearTable(outs);
								}
							}
							Output(num, outs);
							Output(EOFCode, outs);
						}

						public void Encode(Stream os)
						{
							os.WriteByte(Convert.ToByte(initCodeSize));
							curPixel = 0;
							Compress(initCodeSize + 1, os);
							os.WriteByte(0);
						}

						private void Flush(Stream outs)
						{
							if (a_count > 0)
							{
								outs.WriteByte(Convert.ToByte(a_count));
								outs.Write(accum, 0, a_count);
								a_count = 0;
							}
						}

						private int MaxCode(int n_bits)
						{
							return (1 << n_bits) - 1;
						}

						private int NextPixel()
						{
							int upperBound = pixAry.GetUpperBound(0);
							if (curPixel > upperBound)
							{
								return EOF;
							}
							return pixAry[curPixel++] & 0xFF;
						}

						private void Output(int code, Stream outs)
						{
							cur_accum &= masks[cur_bits];
							if (cur_bits > 0)
							{
								cur_accum |= code << cur_bits;
							}
							else
							{
								cur_accum = code;
							}
							cur_bits += n_bits;
							while (cur_bits >= 8)
							{
								Add((byte)(cur_accum & 0xFF), outs);
								cur_accum >>= 8;
								cur_bits -= 8;
							}
							if (free_ent > maxcode || clear_flg)
							{
								if (clear_flg)
								{
									maxcode = MaxCode(n_bits = g_init_bits);
									clear_flg = false;
								}
								else
								{
									n_bits++;
									if (n_bits == maxbits)
									{
										maxcode = maxmaxcode;
									}
									else
									{
										maxcode = MaxCode(n_bits);
									}
								}
							}
							if (code == EOFCode)
							{
								while (cur_bits > 0)
								{
									Add((byte)(cur_accum & 0xFF), outs);
									cur_accum >>= 8;
									cur_bits -= 8;
								}
								Flush(outs);
							}
						}
					}

					internal class NeuQuant
					{
						protected static readonly int netsize = 256;

						protected static readonly int prime1 = 499;

						protected static readonly int prime2 = 491;

						protected static readonly int prime3 = 487;

						protected static readonly int prime4 = 503;

						protected static readonly int minpicturebytes = 3 * prime4;

						protected static readonly int maxnetpos = netsize - 1;

						protected static readonly int netbiasshift = 4;

						protected static readonly int ncycles = 100;

						protected static readonly int intbiasshift = 16;

						protected static readonly int intbias = 1 << intbiasshift;

						protected static readonly int gammashift = 10;

						protected static readonly int gamma = 1 << gammashift;

						protected static readonly int betashift = 10;

						protected static readonly int beta = intbias >> betashift;

						protected static readonly int betagamma = intbias << gammashift - betashift;

						protected static readonly int initrad = netsize >> 3;

						protected static readonly int radiusbiasshift = 6;

						protected static readonly int radiusbias = 1 << radiusbiasshift;

						protected static readonly int initradius = initrad * radiusbias;

						protected static readonly int radiusdec = 30;

						protected static readonly int alphabiasshift = 10;

						protected static readonly int initalpha = 1 << alphabiasshift;

						protected int alphadec;

						protected static readonly int radbiasshift = 8;

						protected static readonly int radbias = 1 << radbiasshift;

						protected static readonly int alpharadbshift = alphabiasshift + radbiasshift;

						protected static readonly int alpharadbias = 1 << alpharadbshift;

						protected byte[] thepicture;

						protected int lengthcount;

						protected int samplefac;

						protected int[][] network;

						protected int[] netindex = new int[256];

						protected int[] bias = new int[netsize];

						protected int[] freq = new int[netsize];

						protected int[] radpower = new int[initrad];

						public NeuQuant(byte[] thepic, int len, int sample)
						{
							thepicture = thepic;
							lengthcount = len;
							samplefac = sample;
							network = new int[netsize][];
							for (int i = 0; i < netsize; i++)
							{
								network[i] = new int[4];
								int[] array = network[i];
								array[0] = (array[1] = (array[2] = (i << netbiasshift + 8) / netsize));
								freq[i] = intbias / netsize;
								bias[i] = 0;
							}
						}

						public byte[] ColorMap()
						{
							byte[] array = new byte[3 * netsize];
							int[] array2 = new int[netsize];
							for (int i = 0; i < netsize; i++)
							{
								array2[network[i][3]] = i;
							}
							int num = 0;
							for (int j = 0; j < netsize; j++)
							{
								int num2 = array2[j];
								array[num++] = (byte)network[num2][0];
								array[num++] = (byte)network[num2][1];
								array[num++] = (byte)network[num2][2];
							}
							return array;
						}

						public void Inxbuild()
						{
							int num = 0;
							int num2 = 0;
							for (int i = 0; i < netsize; i++)
							{
								int[] array = network[i];
								int num3 = i;
								int num4 = array[1];
								int[] array2;
								for (int j = i + 1; j < netsize; j++)
								{
									array2 = network[j];
									if (array2[1] < num4)
									{
										num3 = j;
										num4 = array2[1];
									}
								}
								array2 = network[num3];
								if (i != num3)
								{
									int j = array2[0];
									array2[0] = array[0];
									array[0] = j;
									j = array2[1];
									array2[1] = array[1];
									array[1] = j;
									j = array2[2];
									array2[2] = array[2];
									array[2] = j;
									j = array2[3];
									array2[3] = array[3];
									array[3] = j;
								}
								if (num4 != num)
								{
									netindex[num] = num2 + i >> 1;
									for (int j = num + 1; j < num4; j++)
									{
										netindex[j] = i;
									}
									num = num4;
									num2 = i;
								}
							}
							netindex[num] = num2 + maxnetpos >> 1;
							for (int j = num + 1; j < 256; j++)
							{
								netindex[j] = maxnetpos;
							}
						}

						public void Learn()
						{
							if (lengthcount < minpicturebytes)
							{
								samplefac = 1;
							}
							alphadec = 30 + (samplefac - 1) / 3;
							byte[] array = thepicture;
							int num = 0;
							int num2 = lengthcount;
							int num3 = lengthcount / (3 * samplefac);
							int num4 = num3 / ncycles;
							int num5 = initalpha;
							int num6 = initradius;
							int num7 = num6 >> radiusbiasshift;
							if (num7 <= 1)
							{
								num7 = 0;
							}
							int i;
							for (i = 0; i < num7; i++)
							{
								radpower[i] = num5 * ((num7 * num7 - i * i) * radbias / (num7 * num7));
							}
							int num8 = ((lengthcount < minpicturebytes) ? 3 : ((lengthcount % prime1 != 0) ? (3 * prime1) : ((lengthcount % prime2 != 0) ? (3 * prime2) : ((lengthcount % prime3 == 0) ? (3 * prime4) : (3 * prime3)))));
							i = 0;
							while (i < num3)
							{
								int b = (array[num] & 0xFF) << netbiasshift;
								int g = (array[num + 1] & 0xFF) << netbiasshift;
								int r = (array[num + 2] & 0xFF) << netbiasshift;
								int i2 = Contest(b, g, r);
								Altersingle(num5, i2, b, g, r);
								if (num7 != 0)
								{
									Alterneigh(num7, i2, b, g, r);
								}
								num += num8;
								if (num >= num2)
								{
									num -= lengthcount;
								}
								i++;
								if (num4 == 0)
								{
									num4 = 1;
								}
								if (i % num4 == 0)
								{
									num5 -= num5 / alphadec;
									num6 -= num6 / radiusdec;
									num7 = num6 >> radiusbiasshift;
									if (num7 <= 1)
									{
										num7 = 0;
									}
									for (i2 = 0; i2 < num7; i2++)
									{
										radpower[i2] = num5 * ((num7 * num7 - i2 * i2) * radbias / (num7 * num7));
									}
								}
							}
						}

						public int Map(int b, int g, int r)
						{
							int num = 1000;
							int result = -1;
							int num2 = netindex[g];
							int num3 = num2 - 1;
							while (num2 < netsize || num3 >= 0)
							{
								int[] array;
								int num5;
								int num4;
								if (num2 < netsize)
								{
									array = network[num2];
									num4 = array[1] - g;
									if (num4 >= num)
									{
										num2 = netsize;
									}
									else
									{
										num2++;
										if (num4 < 0)
										{
											num4 = -num4;
										}
										num5 = array[0] - b;
										if (num5 < 0)
										{
											num5 = -num5;
										}
										num4 += num5;
										if (num4 < num)
										{
											num5 = array[2] - r;
											if (num5 < 0)
											{
												num5 = -num5;
											}
											num4 += num5;
											if (num4 < num)
											{
												num = num4;
												result = array[3];
											}
										}
									}
								}
								if (num3 < 0)
								{
									continue;
								}
								array = network[num3];
								num4 = g - array[1];
								if (num4 >= num)
								{
									num3 = -1;
									continue;
								}
								num3--;
								if (num4 < 0)
								{
									num4 = -num4;
								}
								num5 = array[0] - b;
								if (num5 < 0)
								{
									num5 = -num5;
								}
								num4 += num5;
								if (num4 < num)
								{
									num5 = array[2] - r;
									if (num5 < 0)
									{
										num5 = -num5;
									}
									num4 += num5;
									if (num4 < num)
									{
										num = num4;
										result = array[3];
									}
								}
							}
							return result;
						}

						public byte[] Process()
						{
							Learn();
							Unbiasnet();
							Inxbuild();
							return ColorMap();
						}

						public void Unbiasnet()
						{
							for (int i = 0; i < netsize; i++)
							{
								network[i][0] >>= netbiasshift;
								network[i][1] >>= netbiasshift;
								network[i][2] >>= netbiasshift;
								network[i][3] = i;
							}
						}

						protected void Alterneigh(int rad, int i, int b, int g, int r)
						{
							int num = i - rad;
							if (num < -1)
							{
								num = -1;
							}
							int num2 = i + rad;
							if (num2 > netsize)
							{
								num2 = netsize;
							}
							int num3 = i + 1;
							int num4 = i - 1;
							int num5 = 1;
							while (num3 < num2 || num4 > num)
							{
								int num6 = radpower[num5++];
								if (num3 < num2)
								{
									int[] array = network[num3++];
									try
									{
										array[0] -= num6 * (array[0] - b) / alpharadbias;
										array[1] -= num6 * (array[1] - g) / alpharadbias;
										array[2] -= num6 * (array[2] - r) / alpharadbias;
									}
									catch (Exception)
									{
									}
								}
								if (num4 > num)
								{
									int[] array = network[num4--];
									try
									{
										array[0] -= num6 * (array[0] - b) / alpharadbias;
										array[1] -= num6 * (array[1] - g) / alpharadbias;
										array[2] -= num6 * (array[2] - r) / alpharadbias;
									}
									catch (Exception)
									{
									}
								}
							}
						}

						protected void Altersingle(int alpha, int i, int b, int g, int r)
						{
							int[] array = network[i];
							array[0] -= alpha * (array[0] - b) / initalpha;
							array[1] -= alpha * (array[1] - g) / initalpha;
							array[2] -= alpha * (array[2] - r) / initalpha;
						}

						protected int Contest(int b, int g, int r)
						{
							int num = int.MaxValue;
							int num2 = num;
							int num3 = -1;
							int result = num3;
							for (int i = 0; i < netsize; i++)
							{
								int[] obj = network[i];
								int num4 = obj[0] - b;
								if (num4 < 0)
								{
									num4 = -num4;
								}
								int num5 = obj[1] - g;
								if (num5 < 0)
								{
									num5 = -num5;
								}
								num4 += num5;
								num5 = obj[2] - r;
								if (num5 < 0)
								{
									num5 = -num5;
								}
								num4 += num5;
								if (num4 < num)
								{
									num = num4;
									num3 = i;
								}
								int num6 = num4 - (bias[i] >> intbiasshift - netbiasshift);
								if (num6 < num2)
								{
									num2 = num6;
									result = i;
								}
								int num7 = freq[i] >> betashift;
								freq[i] -= num7;
								bias[i] += num7 << gammashift;
							}
							freq[num3] += beta;
							bias[num3] -= betagamma;
							return result;
						}
					}
				}

				public static class Summary
				{
					private static int calc_scale_factor(Tensor tensor)
					{
						if (tensor.dtype != ScalarType.Byte && tensor.dtype != ScalarType.Int8)
						{
							return 255;
						}
						return 1;
					}

					public static Tensorboard.Summary histogram(string name, Tensor values, Tensor bins, long? max_bins = null)
					{
						if (values.device.type != DeviceType.CPU)
						{
							values = values.cpu();
						}
						HistogramProto histo = make_histogram(values, bins, max_bins);
						Tensorboard.Summary summary = new Tensorboard.Summary();
						summary.Value.Add(new Tensorboard.Summary.Types.Value
						{
							Tag = name,
							Histo = histo
						});
						return summary;
					}

					public static Tensorboard.Summary histogram(string name, Tensor values, HistogramBinSelector bins, long? max_bins = null)
					{
						HistogramProto histo = make_histogram(values, bins, max_bins);
						Tensorboard.Summary summary = new Tensorboard.Summary();
						summary.Value.Add(new Tensorboard.Summary.Types.Value
						{
							Tag = name,
							Histo = histo
						});
						return summary;
					}

					public static HistogramProto make_histogram(Tensor values, Tensor bins, long? max_bins = null)
					{
						if (values.numel() == 0L)
						{
							throw new ArgumentException("The input has no element.");
						}
						if (values.dtype != ScalarType.Float64)
						{
							values = values.to_type(ScalarType.Float64);
						}
						values = values.reshape(-1L);
						var (counts, limits) = torch.histogram(values, bins, (Tensor)null, density: false);
						return make_histogram(values, counts, limits, max_bins);
					}

					public static HistogramProto make_histogram(Tensor values, HistogramBinSelector bins, long? max_bins = null)
					{
						if (values.numel() == 0L)
						{
							throw new ArgumentException("The input has no element.");
						}
						if (values.dtype != ScalarType.Float64)
						{
							values = values.to_type(ScalarType.Float64);
						}
						values = values.reshape(-1L);
						var (counts, limits) = torch.histogram(values, bins, ((double min, double max)?)null, density: false);
						return make_histogram(values, counts, limits, max_bins);
					}

					private static HistogramProto make_histogram(Tensor values, Tensor counts, Tensor limits, long? max_bins = null)
					{
						long num = counts.shape[0];
						if (max_bins.HasValue && num > max_bins)
						{
							long num2 = num / max_bins.Value;
							long num3 = num % num2;
							if (num3 != 0L)
							{
								counts = nn.functional.pad(counts, (0L, num2 - num3));
							}
							counts = counts.reshape(-1L, num2).sum(1L);
							Tensor tensor = empty(new long[1] { counts.numel() + 1 }, limits.dtype);
							tensor[new TensorIndex[1] { TensorIndex.Slice(null, -1L) }] = limits[new TensorIndex[1] { TensorIndex.Slice(null, -1L, num2) }];
							tensor[-1L] = limits[-1L];
							limits = tensor;
						}
						Tensor tensor2 = cumsum(greater(counts, 0), 0L);
						Tensor tensor3 = empty(2, tensor2.dtype);
						tensor3[0L] = 0;
						tensor3[1L] = tensor2[-1L] - 1;
						Tensor tensor4 = searchsorted(tensor2, tensor3, out_int32: false, right: true);
						long num4 = tensor4[0L].item<long>();
						long num5 = tensor4[1L].item<long>() + 1;
						Tensor tensor6;
						if (num4 <= 0)
						{
							Tensor[] obj = new Tensor[2]
							{
								torch.tensor(new int[1]),
								null
							};
							Tensor tensor5 = counts;
							TensorIndex[] array = new TensorIndex[1];
							long? stop = num5;
							array[0] = TensorIndex.Slice(null, stop);
							obj[1] = tensor5[array];
							tensor6 = concatenate(obj, 0L);
						}
						else
						{
							tensor6 = counts[new TensorIndex[1] { TensorIndex.Slice(num4 - 1, num5) }];
						}
						counts = tensor6;
						limits = limits[new TensorIndex[1] { TensorIndex.Slice(num4, num5 + 1) }];
						if (counts.numel() == 0L || limits.numel() == 0L)
						{
							throw new ArgumentException("The histogram is empty, please file a bug report.");
						}
						Tensor tensor7 = values.dot(values);
						HistogramProto histogramProto = new HistogramProto();
						histogramProto.Min = values.min().item<double>();
						histogramProto.Max = values.max().item<double>();
						histogramProto.Num = values.shape[0];
						histogramProto.Sum = values.sum().item<double>();
						histogramProto.SumSquares = tensor7.item<double>();
						histogramProto.BucketLimit.AddRange((IEnumerable<double>)limits.data<double>().ToArray());
						histogramProto.Bucket.AddRange((IEnumerable<double>)counts.data<double>().ToArray());
						return histogramProto;
					}

					public static Tensorboard.Summary image(string tag, Tensor tensor, double rescale = 1.0, string dataformats = "NCHW")
					{
						tensor = utils.convert_to_HWC(tensor, dataformats);
						int num = calc_scale_factor(tensor);
						tensor = tensor.to_type(ScalarType.Float32);
						tensor = (tensor * num).clip(0, 255).to_type(ScalarType.Byte);
						Tensorboard.Summary.Types.Image image = make_image(tensor, rescale);
						Tensorboard.Summary summary = new Tensorboard.Summary();
						summary.Value.Add(new Tensorboard.Summary.Types.Value
						{
							Tag = tag,
							Image = image
						});
						return summary;
					}

					public static Tensorboard.Summary image(string tag, string file_name, double rescale = 1.0)
					{
						SKBitmap val = SKBitmap.Decode(file_name);
						try
						{
							Tensorboard.Summary.Types.Image image = make_image(val, rescale);
							Tensorboard.Summary summary = new Tensorboard.Summary();
							summary.Value.Add(new Tensorboard.Summary.Types.Value
							{
								Tag = tag,
								Image = image
							});
							return summary;
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}

					public static Tensorboard.Summary.Types.Image make_image(Tensor tensor, double rescale = 1.0)
					{
						SKBitmap val = TensorToSKBitmap(tensor);
						try
						{
							return make_image(val, rescale);
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}

					internal static Tensorboard.Summary.Types.Image make_image(SKBitmap img, double rescale = 1.0)
					{
						//IL_001c: Unknown result type (might be due to invalid IL or missing references)
						SKBitmap val = img.Copy();
						try
						{
							byte[] array = val.Resize(new SKSizeI((int)((double)val.Width * rescale), (int)((double)val.Height * rescale)), (SKFilterQuality)3).Encode((SKEncodedImageFormat)4, 100).ToArray();
							return new Tensorboard.Summary.Types.Image
							{
								Height = val.Height,
								Width = val.Width,
								Colorspace = 4,
								EncodedImageString = ByteString.CopyFrom(array)
							};
						}
						finally
						{
							((IDisposable)val)?.Dispose();
						}
					}

					public static Tensorboard.Summary video(string tag, Tensor tensor, int fps)
					{
						tensor = utils.prepare_video(tensor);
						int num = calc_scale_factor(tensor);
						tensor = tensor.to_type(ScalarType.Float32);
						tensor = (tensor * num).clip(0, 255).to_type(ScalarType.Byte);
						Tensorboard.Summary.Types.Image image = make_video(tensor, fps);
						Tensorboard.Summary summary = new Tensorboard.Summary();
						summary.Value.Add(new Tensorboard.Summary.Types.Value
						{
							Tag = tag,
							Image = image
						});
						return summary;
					}

					public static Tensorboard.Summary.Types.Image make_video(Tensor tensor, int fps)
					{
						int height = (int)tensor.shape[1];
						int width = (int)tensor.shape[2];
						using GifEncoder.Encoder encoder = new GifEncoder.Encoder();
						encoder.Start();
						encoder.SetRepeat(0);
						encoder.SetFrameRate(fps);
						Tensor[] array = tensor.split(1L);
						for (int i = 0; i < array.Length; i++)
						{
							SKBitmap val = TensorToSKBitmap(array[i].squeeze());
							try
							{
								encoder.AddFrame(val);
							}
							finally
							{
								((IDisposable)val)?.Dispose();
							}
						}
						encoder.Finish();
						Stream stream = encoder.Output();
						stream.Position = 0L;
						return new Tensorboard.Summary.Types.Image
						{
							Height = height,
							Width = width,
							Colorspace = 4,
							EncodedImageString = ByteString.FromStream(stream)
						};
					}

					private unsafe static SKBitmap TensorToSKBitmap(Tensor tensor)
					{
						//IL_0038: Unknown result type (might be due to invalid IL or missing references)
						//IL_003f: Expected O, but got Unknown
						//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
						//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
						int num = (int)tensor.shape[0];
						int num2 = (int)tensor.shape[1];
						int num3 = (int)tensor.shape[2];
						byte[,,] array = tensor.cpu().data<byte>().ToNDArray() as byte[,,];
						SKBitmap val = new SKBitmap(num2, num, (SKColorType)4, (SKAlphaType)1);
						int num4 = 4;
						byte* ptr = (byte*)val.GetPixels().ToPointer();
						for (int i = 0; i < num; i++)
						{
							for (int j = 0; j < num2; j++)
							{
								ptr[j * num4] = array[i, j, 0];
								ptr[j * num4 + 1] = array[i, j, 1];
								ptr[j * num4 + 2] = array[i, j, 2];
								ptr[j * num4 + 3] = ((num3 == 4) ? array[i, j, 3] : byte.MaxValue);
							}
							byte* num5 = ptr;
							SKImageInfo info = val.Info;
							ptr = num5 + ((SKImageInfo)(ref info)).RowBytes;
						}
						return val;
					}

					public static Tensorboard.Summary text(string tag, string text)
					{
						SummaryMetadata.Types.PluginData pluginData = new SummaryMetadata.Types.PluginData
						{
							PluginName = "text",
							Content = ByteString.CopyFromUtf8("")
						};
						SummaryMetadata metadata = new SummaryMetadata
						{
							PluginData = pluginData
						};
						TensorShapeProto tensorShapeProto = new TensorShapeProto();
						tensorShapeProto.Dim.Add(new TensorShapeProto.Types.Dim
						{
							Size = 1L
						});
						TensorProto tensorProto = new TensorProto
						{
							Dtype = DataType.DtString,
							TensorShape = tensorShapeProto
						};
						tensorProto.StringVal.Add(ByteString.CopyFromUtf8(text));
						Tensorboard.Summary summary = new Tensorboard.Summary();
						summary.Value.Add(new Tensorboard.Summary.Types.Value
						{
							Tag = tag + "/text_summary",
							Metadata = metadata,
							Tensor = tensorProto
						});
						return summary;
					}
				}

				internal static class utils
				{
					public static Tensor prepare_video(Tensor V)
					{
						_ = V.shape[0];
						long num = V.shape[1];
						long num2 = V.shape[2];
						long num3 = V.shape[3];
						long num4 = V.shape[4];
						if (V.dtype == ScalarType.Int8 || V.dtype == ScalarType.Byte)
						{
							V = V.to_type(ScalarType.Float32) / 255.0;
						}
						if (!is_power(V.shape[0]))
						{
							int num5 = Convert.ToInt32(Math.Pow(2.0, bit_length(V.shape[0])) - (double)V.shape[0]);
							Tensor[] obj = new Tensor[2] { V, null };
							long[] size = new long[5] { num5, num, num2, num3, num4 };
							Device device = V.device;
							obj[1] = zeros(size, null, device);
							V = cat(obj, 0L);
						}
						long num6 = Convert.ToInt32(Math.Pow(2.0, (bit_length(V.shape[0]) - 1) / 2));
						long num7 = V.shape[0] / num6;
						V = V.reshape(num6, num7, num, num2, num3, num4);
						V = V.permute(2L, 0L, 4L, 1L, 5L, 3L);
						V = V.reshape(num, num6 * num3, num7 * num4, num2);
						return V;
						static int bit_length(long value)
						{
							return Convert.ToString(value, 2).Length;
						}
						static bool is_power(long num8)
						{
							if (num8 != 0L)
							{
								return (num8 & (num8 - 1)) == 0;
							}
							return false;
						}
					}

					public static Tensor make_grid(Tensor I, long ncols = 8L)
					{
						if (I.shape[1] == 1)
						{
							I = I.expand(-1L, 3L);
						}
						Trace.Assert(I.ndim == 4 && I.shape[1] == 3);
						long num = I.shape[0];
						long num2 = I.shape[2];
						long num3 = I.shape[3];
						ncols = Math.Min(ncols, num);
						long num4 = (long)Math.Ceiling((double)num / (double)ncols);
						Tensor tensor = zeros(new long[3]
						{
							3L,
							num2 * num4,
							num3 * ncols
						}, I.dtype);
						long num5 = 0L;
						for (long num6 = 0L; num6 < num4; num6++)
						{
							for (long num7 = 0L; num7 < ncols; num7++)
							{
								if (num5 >= num)
								{
									break;
								}
								tensor.narrow(1L, num6 * num2, num2).narrow(2L, num7 * num3, num3).copy_(I[num5]);
								num5++;
							}
						}
						return tensor;
					}

					public static Tensor convert_to_HWC(Tensor tensor, string input_format)
					{
						Trace.Assert(tensor.shape.Length == input_format.Length, "size of input tensor and input format are different. tensor shape: (" + string.Join(", ", tensor.shape) + "), input_format: " + input_format);
						input_format = input_format.ToUpper();
						if (input_format.Length == 4)
						{
							long[] permutation = "NCHW".Select((char c) => Convert.ToInt64(input_format.IndexOf(c))).ToArray();
							return make_grid(tensor.permute(permutation), 8L).permute(1L, 2L, 0L);
						}
						if (input_format.Length == 3)
						{
							long[] permutation2 = "HWC".Select((char c) => Convert.ToInt64(input_format.IndexOf(c))).ToArray();
							Tensor tensor2 = tensor.permute(permutation2);
							if (tensor2.shape[2] == 1)
							{
								tensor2 = tensor2.expand(-1L, -1L, 3L);
							}
							return tensor2;
						}
						if (input_format.Length == 2)
						{
							long[] permutation3 = "HW".Select((char c) => Convert.ToInt64(input_format.IndexOf(c))).ToArray();
							tensor = tensor.permute(permutation3);
							tensor = tensor.unsqueeze(-1L).expand(-1L, -1L, 3L);
							return tensor;
						}
						throw new NotImplementedException();
					}
				}

				public static SummaryWriter SummaryWriter(string log_dir = null, string filename_suffix = null, bool createRunName = false)
				{
					if (createRunName && !string.IsNullOrEmpty(log_dir))
					{
						log_dir = CreateRunName(log_dir);
					}
					return new SummaryWriter(log_dir, filename_suffix);
				}

				internal static string CreateRunName(string log_dir)
				{
					DateTime now = DateTime.Now;
					string[] abbreviatedMonthNames = CultureInfo.InvariantCulture.DateTimeFormat.AbbreviatedMonthNames;
					string path = $"{abbreviatedMonthNames[now.Month - 1]}{now.Day}_{now.Hour}-{now.Minute}-{now.Second}_{Dns.GetHostName()}";
					log_dir = Path.Combine(log_dir, path);
					return log_dir;
				}
			}
		}

		public class Device
		{
			public DeviceType type { get; private set; }

			public int index { get; private set; } = -1;

			public Device(string description)
			{
				string[] array = description.Split(new char[1] { ':' });
				if (array.Length == 1)
				{
					type = (DeviceType)Enum.Parse(typeof(DeviceType), array[0].ToUpper());
				}
				else if (array.Length == 2)
				{
					type = (DeviceType)Enum.Parse(typeof(DeviceType), array[0].ToUpper());
					index = int.Parse(array[1]);
				}
			}

			public Device(string deviceType, int index = -1)
			{
				type = (DeviceType)Enum.Parse(typeof(DeviceType), deviceType.ToUpper());
				this.index = index;
			}

			public Device(DeviceType deviceType, int index = -1)
			{
				type = deviceType;
				this.index = index;
			}

			public Device(int index)
			{
				type = DeviceType.CUDA;
				this.index = index;
			}

			public override string ToString()
			{
				object obj;
				if (type != DeviceType.CPU)
				{
					if (index != -1)
					{
						return $"{type.ToString().ToLower()}:{index}";
					}
					obj = type.ToString().ToLower();
					if (obj == null)
					{
						return "";
					}
				}
				else
				{
					obj = "cpu";
				}
				return (string)obj;
			}

			public static implicit operator Device(string description)
			{
				return new Device(description);
			}
		}

		public static class distributions
		{
			public static class constraints
			{
				public abstract class Constraint
				{
					public virtual bool is_discrete { get; protected set; }

					public virtual int event_dim { get; protected set; }

					protected Constraint(bool is_discrete, int event_dim)
					{
						this.is_discrete = is_discrete;
						this.event_dim = event_dim;
					}

					protected Constraint()
						: this(is_discrete: false, 0)
					{
					}

					public abstract Tensor check(Tensor value);

					public override string ToString()
					{
						return GetType().Name + "()";
					}
				}

				public class _Dependent : Constraint
				{
					public _Dependent(bool is_discrete = false, int event_dim = 0)
						: base(is_discrete, event_dim)
					{
					}

					public override Tensor check(Tensor value)
					{
						throw new ArgumentException("Cannot determine validity of dependent constraint");
					}
				}

				public class _IndependentConstraint : Constraint
				{
					public Constraint base_constraint { get; private set; }

					public override bool is_discrete => base_constraint.is_discrete;

					public override int event_dim => base_constraint.event_dim;

					public _IndependentConstraint(Constraint base_constraint, int reinterpreted_batch_ndims)
					{
					}

					public override Tensor check(Tensor value)
					{
						throw new NotImplementedException();
					}

					public override string ToString()
					{
						return GetType().Name + "()";
					}
				}

				public class _Boolean : Constraint
				{
					public _Boolean()
						: base(is_discrete: true, 0)
					{
					}

					public override Tensor check(Tensor value)
					{
						return (value == 0) | (value == 1);
					}
				}

				public class _OneHot : Constraint
				{
					public _OneHot()
						: base(is_discrete: true, 1)
					{
					}

					public override Tensor check(Tensor value)
					{
						Tensor tensor = (value == 0) | (value == 1);
						Tensor tensor2 = value.sum(-1L).eq(1);
						return tensor.all(-1L) & tensor2;
					}
				}

				public class _IntegerInterval : Constraint
				{
					public long lower_bound { get; private set; }

					public long upper_bound { get; private set; }

					public _IntegerInterval(long lower_bound, long upper_bound)
						: base(is_discrete: true, 0)
					{
						this.lower_bound = lower_bound;
						this.upper_bound = upper_bound;
					}

					public override Tensor check(Tensor value)
					{
						return (value % 1 == 0) & (lower_bound <= value) & (value <= upper_bound);
					}

					public override string ToString()
					{
						return $"{GetType().Name}(lower_bound={lower_bound},upper_bound={upper_bound})";
					}
				}

				public class _IntegerLessThan : Constraint
				{
					public long upper_bound { get; private set; }

					public _IntegerLessThan(long upper_bound)
						: base(is_discrete: true, 0)
					{
						this.upper_bound = upper_bound;
					}

					public override Tensor check(Tensor value)
					{
						return (value % 1 == 0) & (value <= upper_bound);
					}

					public override string ToString()
					{
						return $"{GetType().Name}(upper_bound={upper_bound})";
					}
				}

				public class _IntegerGreaterThan : Constraint
				{
					public long lower_bound { get; private set; }

					public _IntegerGreaterThan(long lower_bound)
						: base(is_discrete: true, 0)
					{
						this.lower_bound = lower_bound;
					}

					public override Tensor check(Tensor value)
					{
						return (value % 1 == 0) & (lower_bound <= value);
					}

					public override string ToString()
					{
						return $"{GetType().Name}(lower_bound={lower_bound})";
					}
				}

				public class _Real : Constraint
				{
					public _Real()
						: base(is_discrete: false, 0)
					{
					}

					public override Tensor check(Tensor value)
					{
						return value.eq(value);
					}
				}

				public class _Interval : Constraint
				{
					public double lower_bound { get; private set; }

					public double upper_bound { get; private set; }

					public _Interval(double lower_bound, double upper_bound)
						: base(is_discrete: true, 0)
					{
						this.lower_bound = lower_bound;
						this.upper_bound = upper_bound;
					}

					public override Tensor check(Tensor value)
					{
						return (lower_bound <= value) & (value <= upper_bound);
					}

					public override string ToString()
					{
						return $"{GetType().Name}(lower_bound={lower_bound},upper_bound={upper_bound})";
					}
				}

				public class _HalfOpenInterval : Constraint
				{
					public double lower_bound { get; private set; }

					public double upper_bound { get; private set; }

					public _HalfOpenInterval(double lower_bound, double upper_bound)
						: base(is_discrete: true, 0)
					{
						this.lower_bound = lower_bound;
						this.upper_bound = upper_bound;
					}

					public override Tensor check(Tensor value)
					{
						return (lower_bound <= value) & (value < upper_bound);
					}

					public override string ToString()
					{
						return $"{GetType().Name}(lower_bound={lower_bound},upper_bound={upper_bound})";
					}
				}

				public class _GreaterThan : Constraint
				{
					public double lower_bound { get; private set; }

					public _GreaterThan(double lower_bound)
						: base(is_discrete: true, 0)
					{
						this.lower_bound = lower_bound;
					}

					public override Tensor check(Tensor value)
					{
						return lower_bound < value;
					}

					public override string ToString()
					{
						return $"{GetType().Name}(lower_bound={lower_bound})";
					}
				}

				public class _GreaterThanEq : Constraint
				{
					public double lower_bound { get; private set; }

					public _GreaterThanEq(double lower_bound)
						: base(is_discrete: true, 0)
					{
						this.lower_bound = lower_bound;
					}

					public override Tensor check(Tensor value)
					{
						return lower_bound <= value;
					}

					public override string ToString()
					{
						return $"{GetType().Name}(lower_bound={lower_bound})";
					}
				}

				public class _LessThan : Constraint
				{
					public double upper_bound { get; private set; }

					public _LessThan(double upper_bound)
						: base(is_discrete: true, 0)
					{
						this.upper_bound = upper_bound;
					}

					public override Tensor check(Tensor value)
					{
						return value < upper_bound;
					}

					public override string ToString()
					{
						return $"{GetType().Name}(upper_bound={upper_bound})";
					}
				}

				public class _Simplex : Constraint
				{
					public _Simplex()
						: base(is_discrete: false, 1)
					{
					}

					public override Tensor check(Tensor value)
					{
						return (value >= 0).all(-1L) & ((value.sum(-1L) - 1).abs() < 1E-06);
					}
				}

				public class _Multinomial : Constraint
				{
					public long upper_bound { get; private set; }

					public _Multinomial(long upper_bound)
						: base(is_discrete: true, 1)
					{
						this.upper_bound = upper_bound;
					}

					public override Tensor check(Tensor x)
					{
						return (x >= 0).all(-1L) & (x.sum(-1L) <= upper_bound);
					}

					public override string ToString()
					{
						return $"{GetType().Name}(upper_bound={upper_bound})";
					}
				}

				public class _LowerTriangular : Constraint
				{
					public _LowerTriangular()
						: base(is_discrete: false, 2)
					{
					}

					public override Tensor check(Tensor value)
					{
						Tensor tensor = value.tril(0L);
						long[] array = new long[value.shape.Length - 1];
						int i;
						for (i = 0; i < value.shape.Length - 2; i++)
						{
							array[i] = value.shape[i];
						}
						array[i] = -1L;
						return (tensor == value).view(array).min(-1L).values;
					}
				}

				public class _LowerCholesky : Constraint
				{
					public _LowerCholesky()
						: base(is_discrete: false, 2)
					{
					}

					public override Tensor check(Tensor value)
					{
						Tensor tensor = value.tril(0L);
						long[] array = new long[value.shape.Length - 1];
						int i;
						for (i = 0; i < value.shape.Length - 2; i++)
						{
							array[i] = value.shape[i];
						}
						array[i] = -1L;
						Tensor item = (tensor == value).view(array).min(-1L).values;
						Tensor item2 = (value.diagonal(0L, -2L, -1L) > 0).min(-1L).values;
						return item & item2;
					}
				}

				public class _CorrCholesky : Constraint
				{
					private _LowerCholesky lc = new _LowerCholesky();

					public _CorrCholesky()
						: base(is_discrete: false, 2)
					{
					}

					public override Tensor check(Tensor value)
					{
						double num = finfo(value.dtype).eps * (double)value.size(-1) * 10.0;
						Tensor tensor = (linalg.norm(value.detach(), new long[1] { -1L }) - 1.0).abs().le(num).all(-1L);
						return lc.check(value) & tensor;
					}
				}

				public class _Square : Constraint
				{
					public _Square()
						: base(is_discrete: false, 2)
					{
					}

					public override Tensor check(Tensor value)
					{
						long[] array = new long[value.shape.Length - 2];
						for (int i = 0; i < value.shape.Length - 2; i++)
						{
							array[i] = value.shape[i];
						}
						return full(array, value.shape[value.shape.Length - 2] == value.shape[value.shape.Length - 1], @bool, value.device);
					}
				}

				public class _Symmetric : _Square
				{
					public override Tensor check(Tensor value)
					{
						Tensor tensor = base.check(value);
						if (!tensor.all().item<bool>())
						{
							return tensor;
						}
						return value.isclose(value.mT, 1E-05, 1E-06).all(-2L).all(-1L);
					}
				}

				public class _PositiveSemiDefinite : _Symmetric
				{
					public override Tensor check(Tensor value)
					{
						Tensor tensor = base.check(value);
						if (!tensor.all().item<bool>())
						{
							return tensor;
						}
						return linalg.eigvalsh(value).ge(0).all(-1L);
					}
				}

				public class _PositiveDefinite : _Symmetric
				{
					public override Tensor check(Tensor value)
					{
						Tensor tensor = base.check(value);
						if (!tensor.all().item<bool>())
						{
							return tensor;
						}
						return linalg.cholesky_ex(value).info.eq(0);
					}
				}

				public class _Cat : Constraint
				{
					private IList<Constraint> cseq;

					private IList<long> lengths;

					private long dim;

					public override bool is_discrete => cseq.Any((Constraint c) => c.is_discrete);

					public override int event_dim => cseq.Select((Constraint c) => c.event_dim).Max();

					public _Cat(IList<Constraint> cseq, long dim = 0L, IList<long> lengths = null)
					{
						this.cseq = cseq;
						if (lengths == null)
						{
							lengths = Enumerable.Repeat(1L, cseq.Count).ToList();
						}
						this.lengths = lengths;
						this.dim = dim;
					}

					public override Tensor check(Tensor value)
					{
						List<Tensor> list = new List<Tensor>();
						long num = 0L;
						for (int i = 0; i < cseq.Count; i++)
						{
							long num2 = lengths[i];
							Constraint constraint = cseq[i];
							Tensor value2 = value.narrow(dim, num, num2);
							list.Add(constraint.check(value2));
							num += num2;
						}
						return torch.cat((IList<Tensor>)list, dim);
					}
				}

				public class _Stack : Constraint
				{
					private IList<Constraint> cseq;

					private int dim;

					public override bool is_discrete => cseq.Any((Constraint c) => c.is_discrete);

					public override int event_dim
					{
						get
						{
							int num = cseq.Select((Constraint c) => c.event_dim).Max();
							if (dim + num < 0)
							{
								num++;
							}
							return num;
						}
					}

					public _Stack(IList<Constraint> cseq, int dim = 0)
					{
						this.cseq = cseq;
						this.dim = dim;
					}

					public override Tensor check(Tensor value)
					{
						List<Tensor> vs = (from i in Enumerable.Range(0, (int)value.size(dim))
							select value.@select(dim, i)).ToList();
						return torch.stack(from i in Enumerable.Range(0, vs.Count)
							select cseq[i].check(vs[i]), 0L);
					}
				}

				public static _Dependent dependent = new _Dependent();

				public static _Boolean boolean = new _Boolean();

				public static _OneHot one_hot = new _OneHot();

				public static _IntegerGreaterThan nonnegative_integer = new _IntegerGreaterThan(0L);

				public static _IntegerGreaterThan positive_integer = new _IntegerGreaterThan(1L);

				public static _Real real = new _Real();

				public static _IndependentConstraint real_vector = independent(real, 1);

				public static _GreaterThan positive = new _GreaterThan(0.0);

				public static _GreaterThanEq nonnegative = new _GreaterThanEq(0.0);

				public static _Interval unit_interval = new _Interval(0.0, 1.0);

				public static _Simplex simplex = new _Simplex();

				public static _LowerTriangular lower_triangular = new _LowerTriangular();

				public static _LowerCholesky lower_cholesky = new _LowerCholesky();

				public static _CorrCholesky corr_cholesky = new _CorrCholesky();

				public static _Square square = new _Square();

				public static _Symmetric symmetric = new _Symmetric();

				public static _PositiveSemiDefinite positive_semidefinite = new _PositiveSemiDefinite();

				public static _PositiveDefinite positive_definite = new _PositiveDefinite();

				public static _IndependentConstraint independent(Constraint base_constraint, int reinterpreted_batch_ndims)
				{
					return new _IndependentConstraint(base_constraint, reinterpreted_batch_ndims);
				}

				public static _IntegerInterval integer_interval(long lb, long ub)
				{
					return new _IntegerInterval(lb, ub);
				}

				public static _GreaterThan greater_than(double lower_bound)
				{
					return new _GreaterThan(lower_bound);
				}

				public static _GreaterThanEq greater_than_eq(double lower_bound)
				{
					return new _GreaterThanEq(lower_bound);
				}

				public static _LessThan less_than(double upper_bound)
				{
					return new _LessThan(upper_bound);
				}

				public static _Multinomial multinomial(long upper_bound)
				{
					return new _Multinomial(upper_bound);
				}

				public static _Interval interval(double lower_bound, double upper_bound)
				{
					return new _Interval(lower_bound, upper_bound);
				}

				public static _HalfOpenInterval half_open_interval(double lower_bound, double upper_bound)
				{
					return new _HalfOpenInterval(lower_bound, upper_bound);
				}

				public static _Cat cat(IList<Constraint> cseq, long dim = 0L, IList<long> lengths = null)
				{
					return new _Cat(cseq, dim, lengths);
				}

				public static _Stack stack(IList<Constraint> cseq, int dim = 0)
				{
					return new _Stack(cseq, dim);
				}
			}

			public abstract class Distribution : IDisposable
			{
				protected Generator generator;

				private bool disposedValue;

				protected const double euler_constant = 0.5772156649015329;

				public Size batch_shape { get; protected set; }

				public Size event_shape { get; protected set; }

				public abstract Tensor mean { get; }

				public virtual Tensor mode => new Tensor(IntPtr.Zero);

				public abstract Tensor variance { get; }

				public virtual Tensor stddev => variance.sqrt();

				public Distribution(Generator generator, long[] batch_shape = null, long[] event_shape = null)
				{
					this.generator = generator;
					_init((batch_shape != null) ? ((Size)batch_shape) : Size.Empty, (event_shape != null) ? ((Size)event_shape) : Size.Empty);
				}

				public Distribution(Generator generator, Size batch_shape, Size? event_shape = null)
				{
					this.generator = generator;
					_init(batch_shape, event_shape ?? new Size?(Size.Empty));
				}

				protected void _init(Size? batch_shape = null, Size? event_shape = null)
				{
					this.batch_shape = (batch_shape.HasValue ? batch_shape.Value : Size.Empty);
					this.event_shape = (event_shape.HasValue ? event_shape.Value : Size.Empty);
				}

				public virtual Tensor sample(params long[] sample_shape)
				{
					return rsample(sample_shape);
				}

				public Tensor sample(Size sample_shape)
				{
					return sample(sample_shape.Shape);
				}

				public abstract Tensor rsample(params long[] sample_shape);

				public Tensor rsample(Size sample_shape)
				{
					return rsample(sample_shape.Shape);
				}

				public abstract Tensor log_prob(Tensor value);

				public abstract Tensor entropy();

				public abstract Distribution expand(Size batch_shape, Distribution instance = null);

				public virtual Tensor cdf(Tensor value)
				{
					throw new NotImplementedException("Distribution.cdf()");
				}

				public virtual Tensor icdf(Tensor value)
				{
					throw new NotImplementedException("Distribution.icdf()");
				}

				public virtual Tensor enumerate_support(bool expand = true)
				{
					throw new NotImplementedException();
				}

				public virtual Tensor perplexity()
				{
					return exp(entropy());
				}

				protected long[] ExtendedShape(params long[] sample_shape)
				{
					if (batch_shape.Length == 0 && event_shape.Length == 0)
					{
						return sample_shape;
					}
					List<long> list = new List<long>();
					if (sample_shape.Length != 0)
					{
						list.AddRange(sample_shape);
					}
					if (batch_shape.Length > 0)
					{
						list.AddRange(batch_shape);
					}
					if (event_shape.Length > 0)
					{
						list.AddRange(event_shape);
					}
					return list.ToArray();
				}

				protected Tensor LogitsToProbs(Tensor logits, bool isBinary = false)
				{
					if (!isBinary)
					{
						return nn.functional.softmax(logits, -1L);
					}
					return sigmoid(logits);
				}

				protected Tensor ProbsToLogits(Tensor probs, bool isBinary = false)
				{
					probs = ClampProbs(probs);
					if (!isBinary)
					{
						return log(probs);
					}
					return log(probs) - log1p(-probs);
				}

				protected Tensor ClampProbs(Tensor probs)
				{
					double eps = finfo(probs.dtype).eps;
					return probs.clamp(eps, 1.0 - eps);
				}

				protected Tensor ClampByZero(Tensor x)
				{
					return (x.clamp_min(0) + x - x.clamp_max(0)) / 2;
				}

				protected virtual void Dispose(bool disposing)
				{
					if (!disposedValue)
					{
						if (disposing)
						{
							generator?.Dispose();
						}
						disposedValue = true;
					}
				}

				~Distribution()
				{
					Dispose(disposing: false);
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}
			}

			public abstract class ExponentialFamily : Distribution
			{
				protected abstract IList<Tensor> NaturalParams { get; }

				protected abstract Tensor MeanCarrierMeasure { get; }

				protected ExponentialFamily(Generator generator)
					: base(generator)
				{
				}

				protected virtual Tensor LogNormalizer(params Tensor[] parameters)
				{
					throw new NotImplementedException();
				}

				public override Tensor entropy()
				{
					using (NewDisposeScope())
					{
						Tensor tensor = -MeanCarrierMeasure;
						Tensor[] array = NaturalParams.Select((Tensor p) => p.detach().requires_grad_()).ToArray();
						Tensor tensor2 = LogNormalizer(array);
						IList<Tensor> list = autograd.grad(new Tensor[1] { tensor2.sum() }, array, null, retain_graph: false, create_graph: true);
						tensor += tensor2;
						for (int num = 0; num < list.Count; num++)
						{
							Tensor tensor3 = array[num];
							Tensor tensor4 = list[num];
							tensor -= tensor3 * tensor4;
						}
						return tensor.MoveToOuterDisposeScope();
					}
				}
			}

			public static class transforms
			{
				public abstract class Transform
				{
					protected bool _bijective;

					protected constraints.Constraint _domain;

					protected constraints.Constraint _codomain;

					protected Transform _inv;

					public virtual int event_dim
					{
						get
						{
							if (_domain.event_dim == codomain.event_dim)
							{
								return _domain.event_dim;
							}
							throw new InvalidOperationException("Please use either .domain.event_dim or .codomain.event_dim");
						}
					}

					public virtual Transform inv
					{
						get
						{
							Transform transform = null;
							if (_inv != null)
							{
								transform = _inv;
							}
							if (transform == null)
							{
								transform = (_inv = new _InverseTransform(this));
							}
							return transform;
						}
					}

					public virtual constraints.Constraint domain => _domain;

					public virtual constraints.Constraint codomain => _codomain;

					public virtual bool bijective => _bijective;

					public Tensor sign => _sign();

					protected internal virtual Tensor _sign()
					{
						throw new NotImplementedException();
					}

					protected internal abstract Tensor _call(Tensor x);

					protected internal abstract Tensor _inverse(Tensor y);

					protected internal virtual Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						throw new NotImplementedException();
					}

					public Tensor forward(Tensor x)
					{
						return _call(x);
					}

					public virtual long[] forward_shape(long[] shape)
					{
						return shape;
					}

					public virtual long[] inverse_shape(long[] shape)
					{
						return shape;
					}

					protected internal static Tensor _sum_rightmost(Tensor value, int dim)
					{
						if (dim == 0)
						{
							return value;
						}
						long[] array = new long[value.shape.Length - dim + 1];
						int i;
						for (i = 0; i < value.shape.Length - dim; i++)
						{
							array[i] = value.shape[i];
						}
						array[i] = -1L;
						return value.reshape(array).sum(-1L);
					}
				}

				internal class _InverseTransform : Transform
				{
					public override constraints.Constraint domain => _inv.domain;

					public override constraints.Constraint codomain => _inv.codomain;

					public override bool bijective => _inv.bijective;

					public override int event_dim => base.event_dim;

					public override Transform inv => base.inv;

					public _InverseTransform(Transform transform)
					{
						_inv = transform;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return -_inv.log_abs_det_jacobian(y, x);
					}

					protected internal override Tensor _call(Tensor x)
					{
						return _inv._inverse(x);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return _inv._call(y);
					}

					protected internal override Tensor _sign()
					{
						return _inv.sign;
					}

					public override long[] forward_shape(long[] shape)
					{
						return _inv.forward_shape(shape);
					}

					public override long[] inverse_shape(long[] shape)
					{
						return _inv.inverse_shape(shape);
					}
				}

				public class ComposeTransform : Transform
				{
					private Transform[] _parts;

					private Transform[] _reverse_parts;

					public override int event_dim => base.event_dim;

					public override Transform inv
					{
						get
						{
							Transform transform = _inv;
							if (transform == null)
							{
								transform = new ComposeTransform(_reverse_parts.Select((Transform p) => p.inv));
								_inv = transform;
							}
							return _inv;
						}
					}

					public override constraints.Constraint domain
					{
						get
						{
							if (_parts == null)
							{
								return constraints.real;
							}
							int num = _parts.Length;
							constraints.Constraint constraint = _parts[0].domain;
							int num2 = _parts[num - 1].codomain.event_dim;
							Transform[] reverse_parts = _reverse_parts;
							foreach (Transform transform in reverse_parts)
							{
								num2 += transform.domain.event_dim - transform.codomain.event_dim;
								num2 = ((num2 < transform.domain.event_dim) ? transform.domain.event_dim : num2);
							}
							if (num2 > constraint.event_dim)
							{
								constraint = constraints.independent(domain, num2 - domain.event_dim);
							}
							return constraint;
						}
					}

					public override constraints.Constraint codomain
					{
						get
						{
							if (_parts == null)
							{
								return constraints.real;
							}
							int num = _parts.Length;
							constraints.Constraint constraint = _parts[num - 1].domain;
							int num2 = _parts[0].domain.event_dim;
							Transform[] parts = _parts;
							foreach (Transform transform in parts)
							{
								num2 += transform.codomain.event_dim - transform.domain.event_dim;
								num2 = ((num2 < transform.codomain.event_dim) ? transform.codomain.event_dim : num2);
							}
							if (num2 > constraint.event_dim)
							{
								constraint = constraints.independent(codomain, num2 - codomain.event_dim);
							}
							return constraint;
						}
					}

					public override bool bijective => _parts.All((Transform p) => p.bijective);

					public ComposeTransform(IEnumerable<Transform> parts, int cache_size = 0)
					{
						if (parts == null)
						{
							throw new ArgumentNullException("parts cannot be null");
						}
						_parts = parts.ToArray();
						_reverse_parts = parts.Reverse().ToArray();
					}

					protected internal override Tensor _sign()
					{
						Tensor result = 1;
						Transform[] parts = _parts;
						foreach (Transform transform in parts)
						{
							result *= transform.sign;
						}
						return result;
					}

					protected internal override Tensor _call(Tensor x)
					{
						using (NewDisposeScope())
						{
							Transform[] parts = _parts;
							for (int i = 0; i < parts.Length; i++)
							{
								x = parts[i]._call(x);
							}
							return x.MoveToOuterDisposeScope();
						}
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						throw new NotImplementedException();
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						if (_parts == null)
						{
							return zeros_like(x);
						}
						using (NewDisposeScope())
						{
							List<Tensor> list = new List<Tensor>();
							list.Add(x);
							for (int i = 0; i < _parts.Length - 1; i++)
							{
								Transform transform = _parts[i];
								list.Add(transform._call(list[i]));
							}
							list.Add(y);
							List<Tensor> list2 = new List<Tensor>();
							int num = domain.event_dim;
							for (int j = 0; j < _parts.Length - 1; j++)
							{
								Transform transform2 = _parts[j];
								Tensor x2 = list[j];
								_ = list[j + 1];
								list2.Add(Transform._sum_rightmost(transform2.log_abs_det_jacobian(x2, y), num - transform2.domain.event_dim));
								num += transform2.codomain.event_dim - transform2.domain.event_dim;
							}
							Tensor tensor = list2[0];
							for (int k = 1; k < list2.Count; k++)
							{
								tensor += list2[k];
							}
							return tensor.MoveToOuterDisposeScope();
						}
					}

					public override long[] forward_shape(long[] shape)
					{
						Transform[] parts = _parts;
						for (int i = 0; i < parts.Length; i++)
						{
							shape = parts[i].forward_shape(shape);
						}
						return shape;
					}

					public override long[] inverse_shape(long[] shape)
					{
						Transform[] reverse_parts = _reverse_parts;
						for (int i = 0; i < reverse_parts.Length; i++)
						{
							shape = reverse_parts[i].forward_shape(shape);
						}
						return shape;
					}
				}

				public class IndepdenentTransform : Transform
				{
					private Transform base_transform;

					private int reinterpreted_batch_dims;

					public override int event_dim => base.event_dim;

					public override Transform inv => base.inv;

					public override constraints.Constraint domain => constraints.independent(base_transform.domain, reinterpreted_batch_dims);

					public override constraints.Constraint codomain => constraints.independent(base_transform.codomain, reinterpreted_batch_dims);

					public override bool bijective => base_transform.bijective;

					public IndepdenentTransform(Transform base_transform, int reinterpreted_batch_dims)
					{
						this.base_transform = base_transform;
						this.reinterpreted_batch_dims = reinterpreted_batch_dims;
					}

					public override long[] forward_shape(long[] shape)
					{
						return base_transform.forward_shape(shape);
					}

					public override long[] inverse_shape(long[] shape)
					{
						return base_transform.inverse_shape(shape);
					}

					protected internal override Tensor _sign()
					{
						return base_transform._sign();
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						using (NewDisposeScope())
						{
							return Transform._sum_rightmost(base_transform.log_abs_det_jacobian(x, y), reinterpreted_batch_dims).MoveToOuterDisposeScope();
						}
					}

					protected internal override Tensor _call(Tensor x)
					{
						if (x.dim() < domain.event_dim)
						{
							throw new ArgumentException("Too few dimensions on input");
						}
						return base_transform._call(x);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						if (y.dim() < codomain.event_dim)
						{
							throw new ArgumentException("Too few dimensions on input");
						}
						return base_transform._inverse(y);
					}
				}

				public class ReshapeTransform : Transform
				{
					private Size in_shape;

					private Size out_shape;

					public override bool bijective => true;

					public override constraints.Constraint domain => constraints.independent(constraints.real, in_shape.Length);

					public override constraints.Constraint codomain => constraints.independent(constraints.real, out_shape.Length);

					public ReshapeTransform(long[] in_shape, long[] out_shape)
					{
						this.in_shape = in_shape;
						this.out_shape = out_shape;
						if (this.in_shape.numel() != this.out_shape.numel())
						{
							throw new ArgumentException("in_shape, out_shape have different numbers of elements");
						}
					}

					public override long[] forward_shape(long[] shape)
					{
						return base.forward_shape(shape);
					}

					public override long[] inverse_shape(long[] shape)
					{
						return base.inverse_shape(shape);
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						long num = x.shape.Length - (x.dim() - in_shape.Length);
						long[] array = new long[num];
						for (int i = 0; i < num; i++)
						{
							array[i] = x.shape[i];
						}
						return x.new_zeros(array);
					}

					protected internal override Tensor _call(Tensor x)
					{
						long num = x.shape.Length - (x.dim() - in_shape.Length);
						long num2 = out_shape.Length;
						long[] array = new long[num + num2];
						for (int i = 0; i < num; i++)
						{
							array[i] = x.shape[i];
						}
						for (int j = 0; j < num2; j++)
						{
							array[j + num] = out_shape[j];
						}
						return x.reshape(array);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						long num = y.shape.Length - (y.dim() - out_shape.Length);
						long num2 = in_shape.Length;
						long[] array = new long[num2 + num];
						for (int i = 0; i < num; i++)
						{
							array[i] = y.shape[i];
						}
						for (int j = 0; j < num2; j++)
						{
							array[j + num] = in_shape[j];
						}
						return y.reshape(array);
					}
				}

				public class ExpTransform : Transform
				{
					public override constraints.Constraint domain => constraints.real;

					public override constraints.Constraint codomain => constraints.positive;

					public override bool bijective => true;

					protected internal override Tensor _sign()
					{
						return 1;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return x;
					}

					protected internal override Tensor _call(Tensor x)
					{
						return x.exp();
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return y.log();
					}
				}

				public class LogTransform : Transform
				{
					public override constraints.Constraint domain => constraints.positive;

					public override constraints.Constraint codomain => constraints.real;

					public override bool bijective => true;

					protected internal override Tensor _sign()
					{
						return 1;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return -x;
					}

					protected internal override Tensor _call(Tensor x)
					{
						return x.log();
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return y.exp();
					}
				}

				public class PowerTransform : Transform
				{
					private Tensor exponent;

					public override constraints.Constraint domain => constraints.positive;

					public override constraints.Constraint codomain => constraints.positive;

					public override bool bijective => true;

					public PowerTransform(Tensor exponent)
					{
						this.exponent = exponent;
					}

					protected internal override Tensor _sign()
					{
						return 1;
					}

					public override long[] forward_shape(long[] shape)
					{
						return broadcast_shapes(shape, exponent.shape).Shape;
					}

					public override long[] inverse_shape(long[] shape)
					{
						return broadcast_shapes(shape, exponent.shape).Shape;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return WrappedTensorDisposeScope(() => (exponent * y / x).abs().log());
					}

					protected internal override Tensor _call(Tensor x)
					{
						return x.pow(exponent);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return y.pow(1 / exponent);
					}
				}

				public class SigmoidTransform : Transform
				{
					public override constraints.Constraint domain => constraints.real;

					public override constraints.Constraint codomain => constraints.unit_interval;

					public override bool bijective => true;

					protected internal override Tensor _sign()
					{
						return 1;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return -nn.functional.softplus(-x) - nn.functional.softplus(x);
					}

					protected internal override Tensor _call(Tensor x)
					{
						FInfo finfo = torch.finfo(x.dtype);
						return WrappedTensorDisposeScope(() => clamp(sigmoid(x), finfo.tiny, 1.0 - finfo.eps));
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						using (NewDisposeScope())
						{
							FInfo fInfo = finfo(y.dtype);
							y = y.clamp(fInfo.tiny, 1.0 - fInfo.eps);
							return (y.log() - (-y).log1p()).MoveToOuterDisposeScope();
						}
					}
				}

				public class SoftplusTransform : Transform
				{
					public override constraints.Constraint domain => constraints.real;

					public override constraints.Constraint codomain => constraints.positive;

					public override bool bijective => true;

					protected internal override Tensor _sign()
					{
						return 1;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return -nn.functional.softplus(-x);
					}

					protected internal override Tensor _call(Tensor x)
					{
						return nn.functional.softplus(-x);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return (-y).expm1().neg().log() + y;
					}
				}

				public class SoftmaxTransform : Transform
				{
					public override constraints.Constraint domain => constraints.real_vector;

					public override constraints.Constraint codomain => constraints.simplex;

					public override bool bijective => true;

					protected internal override Tensor _call(Tensor x)
					{
						Tensor tensor = (x - x.max(-1L, keepdim: true).values).exp();
						return tensor / tensor.sum(-1L, keepdim: true);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return y.log();
					}
				}

				public class TanhTransform : Transform
				{
					public override constraints.Constraint domain => constraints.real;

					public override constraints.Constraint codomain => constraints.interval(-1.0, 1.0);

					public override bool bijective => true;

					protected internal override Tensor _sign()
					{
						return 1;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						return WrappedTensorDisposeScope(() => 2.0 * (Math.Log(2.0) - x - -nn.functional.softplus(-2.0 * x)));
					}

					protected internal override Tensor _call(Tensor x)
					{
						return x.tanh();
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return y.atanh();
					}
				}

				public class AbsTransform : Transform
				{
					public override constraints.Constraint domain => constraints.real;

					public override constraints.Constraint codomain => constraints.positive;

					protected internal override Tensor _call(Tensor x)
					{
						return x.abs();
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return y;
					}
				}

				public class AffineTransform : Transform
				{
					private Tensor loc;

					private Tensor scale;

					private int _event_dim;

					public override int event_dim => _event_dim;

					public override bool bijective => true;

					public override constraints.Constraint domain
					{
						get
						{
							if (_event_dim != 0)
							{
								return constraints.independent(constraints.real, event_dim);
							}
							return constraints.real;
						}
					}

					public override constraints.Constraint codomain
					{
						get
						{
							if (_event_dim != 0)
							{
								return constraints.independent(constraints.real, event_dim);
							}
							return constraints.real;
						}
					}

					public AffineTransform(double loc, double scale, int event_dim = 0)
					{
						_event_dim = event_dim;
						this.loc = loc;
						this.scale = scale;
					}

					public AffineTransform(Tensor loc, Tensor scale, int event_dim = 0)
					{
						_event_dim = event_dim;
						this.loc = loc;
						this.scale = scale;
					}

					public override long[] forward_shape(long[] shape)
					{
						return broadcast_shapes(shape, loc.shape, scale.shape).Shape;
					}

					public override long[] inverse_shape(long[] shape)
					{
						return broadcast_shapes(shape, loc.shape, scale.shape).Shape;
					}

					protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
					{
						using (NewDisposeScope())
						{
							long[] array = x.shape;
							Tensor tensor = abs(scale).log();
							if (_event_dim > 0)
							{
								long[] array2 = new long[tensor.shape.Length - _event_dim + 1];
								int i;
								for (i = 0; i < tensor.shape.Length - _event_dim; i++)
								{
									array2[i] = tensor.shape[i];
								}
								array2[i] = -1L;
								tensor = tensor.view(array2).sum(-1L);
								long[] array3 = new long[array.Length];
								for (; i < array.Length - _event_dim; i++)
								{
									array3[i] = array[i];
								}
								array = array3;
							}
							return tensor.expand(array).MoveToOuterDisposeScope();
						}
					}

					protected internal override Tensor _call(Tensor x)
					{
						return WrappedTensorDisposeScope(() => loc + scale * x);
					}

					protected internal override Tensor _inverse(Tensor y)
					{
						return WrappedTensorDisposeScope(() => (y - loc) / scale);
					}

					protected internal override Tensor _sign()
					{
						return scale.sign();
					}
				}
			}

			public static Bernoulli Bernoulli(Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new Bernoulli(probs, logits, generator);
			}

			public static Bernoulli Bernoulli(float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new Bernoulli(tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new Bernoulli(null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static Bernoulli Bernoulli(double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new Bernoulli(tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new Bernoulli(null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and 'logits' should be non-null");
			}

			public static Beta Beta(Tensor concentration1, Tensor concentration0, Generator generator = null)
			{
				return new Beta(concentration1, concentration0, generator);
			}

			public static Binomial Binomial(Tensor total_count, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new Binomial(total_count, probs, logits);
			}

			public static Binomial Binomial(int total_count, float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new Binomial(tensor(total_count), tensor(probs.Value));
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new Binomial(tensor(total_count), null, tensor(logits.Value));
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static Binomial Binomial(int total_count, double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new Binomial(tensor(total_count), tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new Binomial(tensor(total_count), null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static Categorical Categorical(Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new Categorical(probs, logits);
			}

			public static Categorical Categorical(int categories, Generator generator = null)
			{
				return new Categorical(tensor(1.0 / (double)categories).expand(categories), null, generator);
			}

			public static Cauchy Cauchy(Tensor loc, Tensor scale, Generator generator = null)
			{
				return new Cauchy(loc, scale, generator);
			}

			public static Chi2 Chi2(Tensor df, Generator generator = null)
			{
				return new Chi2(df, generator);
			}

			public static Dirichlet Dirichlet(Tensor concentration, Generator generator = null)
			{
				return new Dirichlet(concentration, generator);
			}

			public static Exponential Exponential(Tensor rate, Generator generator = null)
			{
				return new Exponential(rate, generator);
			}

			public static ExpRelaxedCategorical ExpRelaxedCategorical(Tensor temperature, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new ExpRelaxedCategorical(temperature, probs, logits, generator);
			}

			public static ExpRelaxedCategorical ExpRelaxedCategorical(Tensor temperature, float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new ExpRelaxedCategorical(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new ExpRelaxedCategorical(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static ExpRelaxedCategorical ExpRelaxedCategorical(Tensor temperature, double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new ExpRelaxedCategorical(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new ExpRelaxedCategorical(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and 'logits' should be non-null");
			}

			public static FisherSnedecor FisherSnedecor(Tensor df1, Tensor df2, Generator generator = null)
			{
				return new FisherSnedecor(df1, df2, generator);
			}

			public static Gamma Gamma(Tensor concentration, Tensor rate, Generator generator = null)
			{
				return new Gamma(concentration, rate, generator);
			}

			public static Geometric Geometric(Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new Geometric(probs, logits, generator);
			}

			public static Gumbel Gumbel(Tensor loc, Tensor scale, Generator generator = null)
			{
				IList<Tensor> list = broadcast_tensors(loc, scale);
				loc = list[0];
				scale = list[1];
				FInfo fInfo = finfo(loc.dtype);
				Uniform base_distribution = Uniform(full_like(loc, fInfo.tiny), full_like(loc, 1.0 - fInfo.eps), generator);
				transforms.Transform[] transforms = new transforms.Transform[4]
				{
					new transforms.LogTransform(),
					new transforms.AffineTransform(0, -ones_like(scale)),
					new transforms.LogTransform(),
					new transforms.AffineTransform(loc, -scale)
				};
				return new Gumbel(loc, scale, base_distribution, transforms, generator);
			}

			public static HalfCauchy HalfCauchy(Tensor scale, Generator generator = null)
			{
				return new HalfCauchy(scale, generator);
			}

			public static HalfNormal HalfNormal(Tensor scale, Generator generator = null)
			{
				return new HalfNormal(scale, generator);
			}

			public static Independent Independent(Distribution base_distribution, int reinterpreted_batch_dims, Generator generator = null)
			{
				return new Independent(base_distribution, reinterpreted_batch_dims, generator);
			}

			public static Kumaraswamy Kumaraswamy(Tensor concentration1, Tensor concentration0, Generator generator = null)
			{
				return new Kumaraswamy(concentration1, concentration0, generator);
			}

			public static Laplace Laplace(Tensor loc, Tensor scale, Generator generator = null)
			{
				return new Laplace(loc, scale, generator);
			}

			public static Laplace Laplace(float loc, float scale = 1f, Generator generator = null)
			{
				return new Laplace(tensor(loc), tensor(scale), generator);
			}

			public static Laplace Laplace(double loc, double scale = 1.0, Generator generator = null)
			{
				return new Laplace(tensor(loc), tensor(scale), generator);
			}

			public static LogitRelaxedBernoulli LogitRelaxedBernoulli(Tensor temperature, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new LogitRelaxedBernoulli(temperature, probs, logits, generator);
			}

			public static LogitRelaxedBernoulli LogitRelaxedBernoulli(Tensor temperature, float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new LogitRelaxedBernoulli(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new LogitRelaxedBernoulli(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static LogitRelaxedBernoulli LogitRelaxedBernoulli(Tensor temperature, double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new LogitRelaxedBernoulli(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new LogitRelaxedBernoulli(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and 'logits' should be non-null");
			}

			public static LogNormal LogNormal(Tensor loc, Tensor scale, Generator generator = null)
			{
				return new LogNormal(loc, scale, generator);
			}

			public static Multinomial Multinomial(int total_count, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new Multinomial(total_count, probs, logits, generator);
			}

			public static Multinomial Multinomial(int total_count, int categories, Generator generator = null)
			{
				Tensor probs = tensor(1.0 / (double)categories).expand(categories);
				return new Multinomial(total_count, probs, null, generator);
			}

			public static MultivariateNormal MultivariateNormal(Tensor loc, Tensor covariance_matrix = null, Tensor precision_matrix = null, Tensor scale_tril = null, Generator generator = null)
			{
				return new MultivariateNormal(loc, covariance_matrix, precision_matrix, scale_tril, generator);
			}

			public static NegativeBinomial NegativeBinomial(Tensor total_count, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new NegativeBinomial(total_count, probs, logits);
			}

			public static NegativeBinomial NegativeBinomial(int total_count, float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new NegativeBinomial(tensor(total_count), tensor(probs.Value));
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new NegativeBinomial(tensor(total_count), null, tensor(logits.Value));
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static NegativeBinomial NegativeBinomial(int total_count, double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new NegativeBinomial(tensor(total_count), tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new NegativeBinomial(tensor(total_count), null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static Normal Normal(Tensor loc, Tensor scale, Generator generator = null)
			{
				return new Normal(loc, scale, generator);
			}

			public static Normal Normal(float loc, float scale = 1f, Generator generator = null)
			{
				return new Normal(tensor(loc), tensor(scale), generator);
			}

			public static Normal Normal(double loc, double scale = 1.0, Generator generator = null)
			{
				return new Normal(tensor(loc), tensor(scale), generator);
			}

			public static OneHotCategorical OneHotCategorical(Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new OneHotCategorical(probs, logits, generator);
			}

			public static OneHotCategorical OneHotCategorical(float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new OneHotCategorical(tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new OneHotCategorical(null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static OneHotCategorical OneHotCategorical(double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new OneHotCategorical(tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new OneHotCategorical(null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and 'logits' should be non-null");
			}

			public static Pareto Pareto(Tensor scale, Tensor alpha, Generator generator = null)
			{
				IList<Tensor> list = broadcast_tensors(scale, alpha);
				scale = list[0];
				alpha = list[1];
				Exponential base_distribution = Exponential(alpha, generator);
				transforms.Transform[] transforms = new transforms.Transform[2]
				{
					new transforms.ExpTransform(),
					new transforms.AffineTransform(0, scale)
				};
				return new Pareto(scale, alpha, base_distribution, transforms, generator);
			}

			public static Poisson Poisson(Tensor rate, Generator generator = null)
			{
				return new Poisson(rate, generator);
			}

			public static Poisson Poisson(float rate, Generator generator = null)
			{
				return new Poisson(tensor(rate), generator);
			}

			public static Poisson Poisson(double rate, Generator generator = null)
			{
				return new Poisson(tensor(rate), generator);
			}

			public static RelaxedBernoulli RelaxedBernoulli(Tensor temperature, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new RelaxedBernoulli(temperature, probs, logits, generator);
			}

			public static RelaxedBernoulli RelaxedBernoulli(Tensor temperature, float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new RelaxedBernoulli(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new RelaxedBernoulli(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static RelaxedBernoulli RelaxedBernoulli(Tensor temperature, double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new RelaxedBernoulli(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new RelaxedBernoulli(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and 'logits' should be non-null");
			}

			public static RelaxedOneHotCategorical RelaxedOneHotCategorical(Tensor temperature, Tensor probs = null, Tensor logits = null, Generator generator = null)
			{
				return new RelaxedOneHotCategorical(temperature, probs, logits, generator);
			}

			public static RelaxedOneHotCategorical RelaxedOneHotCategorical(Tensor temperature, float? probs, float? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new RelaxedOneHotCategorical(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new RelaxedOneHotCategorical(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}

			public static RelaxedOneHotCategorical RelaxedOneHotCategorical(Tensor temperature, double? probs, double? logits, Generator generator = null)
			{
				if (probs.HasValue && !logits.HasValue)
				{
					return new RelaxedOneHotCategorical(temperature, tensor(probs.Value), null, generator);
				}
				if (!probs.HasValue && logits.HasValue)
				{
					return new RelaxedOneHotCategorical(temperature, null, tensor(logits.Value), generator);
				}
				throw new ArgumentException("One and only one of 'probs' and 'logits' should be non-null");
			}

			public static Uniform Uniform(Tensor low, Tensor high, Generator generator = null)
			{
				return new Uniform(low, high, generator);
			}

			public static Weibull Weibull(Tensor scale, Tensor concentration, Generator generator = null)
			{
				IList<Tensor> list = broadcast_tensors(scale, concentration);
				scale = list[0].alias().DetachFromDisposeScope();
				concentration = list[1].alias().DetachFromDisposeScope();
				Tensor tensor = concentration.reciprocal();
				Exponential base_distribution = Exponential(ones_like(scale), generator);
				transforms.Transform[] transforms = new transforms.Transform[2]
				{
					new transforms.PowerTransform(tensor),
					new transforms.AffineTransform(0, -ones_like(scale))
				};
				return new Weibull(scale, concentration, tensor, base_distribution, transforms, generator);
			}
		}

		public static class fft
		{
			public static Tensor fft_(Tensor input, long n = -1L, long dim = -1L, FFTNormType norm = FFTNormType.Backward)
			{
				IntPtr intPtr = NativeMethods.THSTensor_fft(input.Handle, n, dim, (sbyte)norm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor ifft(Tensor input, long n = -1L, long dim = -1L, FFTNormType norm = FFTNormType.Backward)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ifft(input.Handle, n, dim, (sbyte)norm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor fft2(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("fft2() input should be at least 2D");
				}
				if (dim == null)
				{
					dim = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_fft2(input.Handle, (IntPtr)ptr, (IntPtr)ptr2, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor ifft2(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("ifft2() input should be at least 2D");
				}
				if (dim == null)
				{
					dim = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_ifft2(input.Handle, (IntPtr)ptr, (IntPtr)ptr2, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor fftn(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				int s_length = ((s != null) ? s.Length : 0);
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_fftn(input.Handle, (IntPtr)ptr, s_length, (IntPtr)ptr2, dim_length, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor ifftn(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				int s_length = ((s != null) ? s.Length : 0);
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_ifftn(input.Handle, (IntPtr)ptr, s_length, (IntPtr)ptr2, dim_length, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public static Tensor irfft(Tensor input, long n = -1L, long dim = -1L, FFTNormType norm = FFTNormType.Backward)
			{
				IntPtr intPtr = NativeMethods.THSTensor_irfft(input.Handle, n, dim, (sbyte)norm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor rfft(Tensor input, long n = -1L, long dim = -1L, FFTNormType norm = FFTNormType.Backward)
			{
				IntPtr intPtr = NativeMethods.THSTensor_rfft(input.Handle, n, dim, (sbyte)norm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor rfft2(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("rfft2() input should be at least 2D");
				}
				if (dim == null)
				{
					dim = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_rfft2(input.Handle, (IntPtr)ptr, (IntPtr)ptr2, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor irfft2(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("irfft2() input should be at least 2D");
				}
				if (dim == null)
				{
					dim = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_irfft2(input.Handle, (IntPtr)ptr, (IntPtr)ptr2, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor rfftn(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				int s_length = ((s != null) ? s.Length : 0);
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_rfftn(input.Handle, (IntPtr)ptr, s_length, (IntPtr)ptr2, dim_length, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor irfftn(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				int s_length = ((s != null) ? s.Length : 0);
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_irfftn(input.Handle, (IntPtr)ptr, s_length, (IntPtr)ptr2, dim_length, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public static Tensor hfft(Tensor input, long n = -1L, long dim = -1L, FFTNormType norm = FFTNormType.Backward)
			{
				IntPtr intPtr = NativeMethods.THSTensor_hfft(input.Handle, n, dim, (sbyte)norm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor ihfft(Tensor input, long n = -1L, long dim = -1L, FFTNormType norm = FFTNormType.Backward)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ihfft(input.Handle, n, dim, (sbyte)norm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor fftshift(Tensor input, long[] dim = null)
			{
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = dim)
				{
					IntPtr intPtr = NativeMethods.THSTensor_fftshift(input.Handle, (IntPtr)ptr, dim_length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe static Tensor ifftshift(Tensor input, long[] dim = null)
			{
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = dim)
				{
					IntPtr intPtr = NativeMethods.THSTensor_ifftshift(input.Handle, (IntPtr)ptr, dim_length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public static Tensor fftfreq(long n, double d = 1.0, ScalarType? dtype = null, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				if (!dtype.HasValue)
				{
					dtype = get_default_dtype();
				}
				IntPtr intPtr = NativeMethods.THSTensor_fftfreq(n, d, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_fftfreq(n, d, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor rfftfreq(long n, double d = 1.0, ScalarType? dtype = null, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				if (!dtype.HasValue)
				{
					dtype = get_default_dtype();
				}
				IntPtr intPtr = NativeMethods.THSTensor_rfftfreq(n, d, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_rfftfreq(n, d, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor hfft2(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("hfft2() input should be at least 2D");
				}
				if (dim == null)
				{
					dim = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_hfft2(input.Handle, (IntPtr)ptr, (IntPtr)ptr2, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor ihfft2(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("ihfft2() input should be at least 2D");
				}
				if (dim == null)
				{
					dim = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_ihfft2(input.Handle, (IntPtr)ptr, (IntPtr)ptr2, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor hfftn(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("hfftn() input should be at least 2D");
				}
				int s_length = ((s != null) ? s.Length : 0);
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_hfftn(input.Handle, (IntPtr)ptr, s_length, (IntPtr)ptr2, dim_length, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public unsafe static Tensor ihfftn(Tensor input, long[] s = null, long[] dim = null, FFTNormType norm = FFTNormType.Backward)
			{
				if (input.Dimensions < 2)
				{
					throw new ArgumentException("ihfftn() input should be at least 2D");
				}
				int s_length = ((s != null) ? s.Length : 0);
				int dim_length = ((dim != null) ? dim.Length : 0);
				fixed (long* ptr = s)
				{
					fixed (long* ptr2 = dim)
					{
						IntPtr intPtr = NativeMethods.THSTensor_ihfftn(input.Handle, (IntPtr)ptr, s_length, (IntPtr)ptr2, dim_length, (sbyte)norm);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}
		}

		public class Generator : IDisposable
		{
			public IntPtr Handle { get; private set; }

			public Device device { get; private set; }

			public static Generator Default => new Generator(NativeMethods.THSGenerator_default_generator());

			public Tensor get_state()
			{
				IntPtr intPtr = NativeMethods.THSGenerator_get_rng_state(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public void set_state(Tensor value)
			{
				NativeMethods.THSGenerator_set_rng_state(Handle, value?.Handle ?? IntPtr.Zero);
				CheckForErrors();
			}

			public Generator manual_seed(long seed)
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				NativeMethods.THSGenerator_gen_manual_seed(Handle, seed);
				return this;
			}

			public long seed()
			{
				long ticks = DateTime.UtcNow.Ticks;
				TryInitializeDeviceType(DeviceType.CUDA);
				NativeMethods.THSGenerator_gen_manual_seed(Handle, ticks);
				return ticks;
			}

			internal Generator(IntPtr nativeHandle)
			{
				Handle = nativeHandle;
				device = CPU;
			}

			public Generator(ulong seed = 0uL, Device? device = null)
				: this(NativeMethods.THSGenerator_new(seed, (long)(device?.type ?? DeviceType.CPU), device?.index ?? (-1)))
			{
				this.device = device ?? CPU;
			}

			public long initial_seed()
			{
				return NativeMethods.THSGenerator_initial_seed(Handle);
			}

			protected virtual void Dispose(bool disposing)
			{
				if (Handle != IntPtr.Zero)
				{
					IntPtr handle = Handle;
					Handle = IntPtr.Zero;
					NativeMethods.THSGenerator_dispose(handle);
				}
			}

			~Generator()
			{
				Dispose(disposing: false);
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}
		}

		public static class hub
		{
			private static Func<bool, IProgressBar> createProgressBarFunc;

			public static void set_create_progress_bar_func(Func<bool, IProgressBar> func)
			{
				createProgressBarFunc = func;
			}

			public static IProgressBar CreateProgressBar(bool hidden)
			{
				if (createProgressBarFunc == null)
				{
					return new ConsoleProgressBar(hidden);
				}
				return createProgressBarFunc(hidden);
			}

			public static void download_url_to_file(string url, string dst, string hash_prefix = null, bool progress = true)
			{
				try
				{
					Task.Run(async delegate
					{
						await download_url_to_file_async(url, dst, hash_prefix, progress);
					}).Wait();
				}
				catch (AggregateException ex)
				{
					throw ex.InnerException;
				}
			}

			public static async Task download_url_to_file_async(string url, string dst, string hash_prefix = null, bool progress = true, CancellationToken cancellationToken = default(CancellationToken))
			{
				_ = 4;
				try
				{
					using IProgressBar progress_bar = CreateProgressBar(!progress);
					using HttpClient httpClient = new HttpClient();
					using HttpResponseMessage response = await httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
					response.EnsureSuccessStatusCode();
					progress_bar.Maximum = response.Content.Headers.ContentLength;
					using FileStream writer = File.OpenWrite(dst);
					byte[] buffer = new byte[65536];
					if (!progress)
					{
						await response.Content.CopyToAsync(writer);
					}
					else
					{
						Stream reader = await response.Content.ReadAsStreamAsync();
						while (true)
						{
							int ret = await reader.ReadAsync(buffer, 0, buffer.Length, cancellationToken);
							if (ret == 0)
							{
								break;
							}
							await writer.WriteAsync(buffer, 0, ret, cancellationToken);
							progress_bar.Value += ret;
						}
					}
				}
				catch (Exception)
				{
					if (File.Exists(dst))
					{
						File.Delete(dst);
					}
					throw;
				}
				string fileChecksum = GetFileChecksum(dst);
				if (hash_prefix != null && !fileChecksum.StartsWith(hash_prefix))
				{
					throw new InvalidDataException("invalid hash value (expected \"" + hash_prefix + "\", got \"" + fileChecksum + "\"");
				}
			}

			private static string GetFileChecksum(string path)
			{
				using SHA256 sHA = SHA256.Create();
				using FileStream inputStream = File.OpenRead(path);
				byte[] array = sHA.ComputeHash(inputStream);
				StringBuilder stringBuilder = new StringBuilder();
				byte[] array2 = array;
				foreach (byte b in array2)
				{
					stringBuilder.Append($"{b:x2}");
				}
				return stringBuilder.ToString();
			}
		}

		public static class jit
		{
			public class CompilationUnit : IDisposable
			{
				internal IntPtr handle;

				internal CompilationUnit(IntPtr handle)
				{
					this.handle = handle;
				}

				~CompilationUnit()
				{
					Dispose(disposing: false);
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				protected virtual void Dispose(bool disposing)
				{
					if (disposing && handle != IntPtr.Zero)
					{
						handle = IntPtr.Zero;
					}
				}

				public object invoke(string name, params object[] objs)
				{
					if (string.IsNullOrEmpty(name))
					{
						throw new ArgumentNullException("method name");
					}
					TensorOrScalar[] array = null;
					sbyte typeCode = 0;
					using NativeTensorOrScalarIndexedArray nativeTensorOrScalarIndexedArray = new NativeTensorOrScalarIndexedArray();
					int count;
					IntPtr tensors = ScriptModule.DetermineArgumentTypeRefs(objs, out count, nativeTensorOrScalarIndexedArray);
					int count2 = nativeTensorOrScalarIndexedArray.Count;
					NativeMethods.THSJIT_CompilationUnit_Invoke(handle, name, tensors, count, nativeTensorOrScalarIndexedArray.CreateArray, out typeCode, count2);
					CheckForErrors();
					array = nativeTensorOrScalarIndexedArray.ToToSArray(count2);
					return ScriptModule.ProcessReturnValue(name, nativeTensorOrScalarIndexedArray, array, typeCode);
				}

				public TResult invoke<TResult>(string name, params object[] inputs)
				{
					return (TResult)invoke(name, inputs);
				}

				public TResult invoke<T, TResult>(string name, params T[] inputs)
				{
					return (TResult)invoke(name, inputs);
				}
			}

			public class ScriptModule : nn.Module
			{
				public override bool training
				{
					get
					{
						bool result = NativeMethods.THSJIT_Module_is_training(handle);
						CheckForErrors();
						return result;
					}
				}

				internal ScriptModule(IntPtr handle)
					: base(new HType(handle, ownsHandle: true, NativeMethods.THSJIT_Module_dispose), null)
				{
				}

				protected override (string name, Parameter parameter)[] _named_parameters()
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSJIT_Module_named_parameters(handle, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return array.Select((IntPtr x, int i) => (Marshal.PtrToStringAnsi(strArray[i]), new Parameter(x))).ToArray();
				}

				protected override (string name, Tensor buffer)[] _named_buffers()
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSJIT_Module_named_buffers(handle, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return array.Select((IntPtr x, int i) => (Marshal.PtrToStringAnsi(strArray[i]), new Tensor(x))).ToArray();
				}

				public (string name, Tensor buffer)[] named_attributes(bool recurse = true)
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSJIT_Module_named_attributes(handle, recurse, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return array.Select((IntPtr x, int i) => (Marshal.PtrToStringAnsi(strArray[i]), new Tensor(x))).ToArray();
				}

				public void set_attribute(string name, Tensor buffer)
				{
					NativeMethods.THSJIT_Module_set_attribute(handle, name, buffer.Handle);
					CheckForErrors();
				}

				public override IEnumerable<(string name, nn.Module module)> named_modules()
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSJIT_Module_named_modules(handle, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return from m in array.Select((IntPtr x, int i) => ((string, nn.Module))(Marshal.PtrToStringAnsi(strArray[i]), new ScriptModule(x)))
						where !string.IsNullOrEmpty(m.Item1)
						select m;
				}

				public override IEnumerable<(string name, nn.Module module)> named_children()
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSJIT_Module_named_children(handle, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return array.Select((IntPtr x, int i) => ((string, nn.Module))(Marshal.PtrToStringAnsi(strArray[i]), new ScriptModule(x)));
				}

				public int GetNumberOfInputs()
				{
					return NativeMethods.THSJIT_Module_num_inputs(handle);
				}

				public int GetNumberOfOutputs()
				{
					return NativeMethods.THSJIT_Module_num_outputs(handle);
				}

				public override void train(bool on = true)
				{
					NativeMethods.THSJIT_Module_train(handle, on);
					CheckForErrors();
				}

				public override void eval()
				{
					NativeMethods.THSJIT_Module_eval(handle);
					CheckForErrors();
				}

				public override void zero_grad(bool set_to_none = true)
				{
					NativeMethods.THSJIT_Module_zero_grad(handle, set_to_none);
					CheckForErrors();
					if (!set_to_none)
					{
						return;
					}
					foreach (Parameter item in parameters())
					{
						using Tensor tensor = item.grad;
						if ((object)tensor != null)
						{
							item.grad = null;
						}
					}
				}

				protected internal override nn.Module _to(Device device, ScalarType dtype, bool non_blocking)
				{
					if (device.type != DeviceType.CUDA)
					{
						device = new Device(device.type);
					}
					if (device.type == DeviceType.CUDA && !cuda.is_available())
					{
						throw new InvalidOperationException("CUDA is not available.");
					}
					InitializeDeviceType(device.type);
					NativeMethods.THSJIT_Module_to_device_dtype(handle, (sbyte)dtype, (long)device.type, device.index);
					CheckForErrors();
					_toEpilog(device, dtype, non_blocking);
					_toScriptEpilog(device, dtype, non_blocking);
					return this;
				}

				protected internal override nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
				{
					if (deviceType != DeviceType.CUDA)
					{
						deviceIndex = -1;
					}
					if (deviceType == DeviceType.CUDA && !cuda.is_available())
					{
						throw new InvalidOperationException("CUDA is not available.");
					}
					if (deviceType != _deviceType || deviceIndex != _deviceIndex)
					{
						InitializeDeviceType(deviceType);
						NativeMethods.THSJIT_Module_to_device(handle, (long)deviceType, deviceIndex);
						CheckForErrors();
						_toEpilog(deviceType, deviceIndex, non_blocking);
						_toScriptEpilog(deviceType, deviceIndex, non_blocking);
					}
					return this;
				}

				protected internal override nn.Module _to(ScalarType dtype, bool non_blocking)
				{
					NativeMethods.THSJIT_Module_to_dtype(handle, (sbyte)dtype);
					CheckForErrors();
					_toEpilog(dtype, non_blocking);
					_toScriptEpilog(dtype, non_blocking);
					return this;
				}

				protected void _toScriptEpilog(ScalarType dtype, bool non_blocking)
				{
					_toScriptEpilog(dtype, null, non_blocking);
				}

				protected void _toScriptEpilog(Device device, ScalarType dtype, bool non_blocking)
				{
					_toScriptEpilog(dtype, device, non_blocking);
				}

				protected void _toScriptEpilog(DeviceType deviceType, int deviceIndex, bool non_blocking)
				{
					_toScriptEpilog(null, new Device(deviceType, deviceIndex), non_blocking);
				}

				private void _toScriptEpilog(ScalarType? dtype, Device device, bool non_blocking)
				{
					(string, Tensor)[] array = named_attributes(recurse: false);
					for (int i = 0; i < array.Length; i++)
					{
						var (text, tensor) = array[i];
						if (text != null && tensor.toWillCopy(dtype ?? tensor.dtype, device ?? tensor.device))
						{
							set_attribute(text, tensor.to(dtype ?? tensor.dtype, device ?? tensor.device, copy: false, disposeAfter: true, non_blocking));
						}
					}
				}

				public object forward(params object[] input)
				{
					TensorOrScalar[] array = null;
					sbyte typeCode = 0;
					using NativeTensorOrScalarIndexedArray nativeTensorOrScalarIndexedArray = new NativeTensorOrScalarIndexedArray();
					int count;
					IntPtr tensors = DetermineArgumentTypeRefs(input, out count, nativeTensorOrScalarIndexedArray);
					int count2 = nativeTensorOrScalarIndexedArray.Count;
					NativeMethods.THSJIT_Module_forward(handle, tensors, count, nativeTensorOrScalarIndexedArray.CreateArray, out typeCode, count2);
					CheckForErrors();
					array = nativeTensorOrScalarIndexedArray.ToToSArray(count2);
					return ProcessReturnValue(name, nativeTensorOrScalarIndexedArray, array, typeCode);
				}

				public object call(params object[] input)
				{
					return forward(input);
				}

				public object invoke(string name, params object[] objs)
				{
					if (string.IsNullOrEmpty(name))
					{
						throw new ArgumentNullException("method name");
					}
					TensorOrScalar[] array = null;
					sbyte typeCode = 0;
					using NativeTensorOrScalarIndexedArray nativeTensorOrScalarIndexedArray = new NativeTensorOrScalarIndexedArray();
					int count;
					IntPtr tensors = DetermineArgumentTypeRefs(objs, out count, nativeTensorOrScalarIndexedArray);
					int count2 = nativeTensorOrScalarIndexedArray.Count;
					NativeMethods.THSJIT_Module_invoke(handle, name, tensors, count, nativeTensorOrScalarIndexedArray.CreateArray, out typeCode, count2);
					CheckForErrors();
					array = nativeTensorOrScalarIndexedArray.ToToSArray(count2);
					return ProcessReturnValue(name, nativeTensorOrScalarIndexedArray, array, typeCode);
				}

				internal static IntPtr DetermineArgumentTypeRefs(object[] objs, out int count, NativeTensorOrScalarIndexedArray allocator)
				{
					count = objs.Length;
					IntPtr intPtr = allocator.CreateArray(allocator.Count, objs.Length);
					for (int i = 0; i < objs.Length; i++)
					{
						object obj = objs[i];
						if (!(obj is Tensor tensor))
						{
							if (!(obj is Scalar scalar))
							{
								if (!(obj is float num))
								{
									if (!(obj is double num2))
									{
										if (!(obj is bool flag))
										{
											if (!(obj is int num3))
											{
												if (!(obj is long num4))
												{
													if (obj is Tensor[] array)
													{
														int index = i;
														long type_code = 5L;
														long array_index = array.Length;
														object[] objs2 = array;
														NativeMethods.THSJIT_SetTensorOrScalar(intPtr, index, type_code, array_index, DetermineArgumentTypeRefs(objs2, out var _, allocator));
													}
													else
													{
														if (objs[i] != null)
														{
															throw new NotImplementedException("Passing arguments of type " + objs[i].GetType().Name + " to TorchScript.");
														}
														NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 8L, 0L, IntPtr.Zero);
													}
												}
												else
												{
													NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 1L, 0L, ((Scalar)num4).Handle);
												}
											}
											else
											{
												NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 3L, 0L, (IntPtr)num3);
											}
										}
										else
										{
											NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 2L, 0L, (IntPtr)(long)(flag ? 1 : 0));
										}
									}
									else
									{
										NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 1L, 0L, ((Scalar)num2).Handle);
									}
								}
								else
								{
									NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 1L, 0L, ((Scalar)num).Handle);
								}
							}
							else
							{
								NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 1L, 0L, scalar.Handle);
							}
						}
						else
						{
							NativeMethods.THSJIT_SetTensorOrScalar(intPtr, i, 0L, 0L, tensor.Handle);
						}
					}
					return intPtr;
				}

				internal static object ProcessReturnValue(string name, NativeTensorOrScalarIndexedArray allocator, TensorOrScalar[] ptrArray, long typeCode)
				{
					long num = typeCode - 1;
					if ((ulong)num <= 9uL)
					{
						switch (num)
						{
						case 0L:
							return new Tensor(ptrArray[0].Handle);
						case 1L:
							switch (ptrArray.Length)
							{
							case 1:
								return new Tensor(ptrArray[0].Handle);
							case 2:
								return (new Tensor(ptrArray[0].Handle), new Tensor(ptrArray[1].Handle));
							case 3:
								return (new Tensor(ptrArray[0].Handle), new Tensor(ptrArray[1].Handle), new Tensor(ptrArray[2].Handle));
							case 4:
								return (new Tensor(ptrArray[0].Handle), new Tensor(ptrArray[1].Handle), new Tensor(ptrArray[2].Handle), new Tensor(ptrArray[3].Handle));
							case 5:
								return (new Tensor(ptrArray[0].Handle), new Tensor(ptrArray[1].Handle), new Tensor(ptrArray[2].Handle), new Tensor(ptrArray[3].Handle), new Tensor(ptrArray[4].Handle));
							default:
							{
								Tensor[] array7 = new Tensor[ptrArray.Length];
								for (int num2 = 0; num2 < ptrArray.Length; num2++)
								{
									array7[num2] = new Tensor(ptrArray[num2].Handle);
								}
								return array7;
							}
							}
						case 2L:
						{
							Tensor[] array5 = new Tensor[ptrArray.Length];
							for (int m = 0; m < ptrArray.Length; m++)
							{
								array5[m] = new Tensor(ptrArray[m].Handle);
							}
							return array5;
						}
						case 3L:
							return new Scalar(ptrArray[0].Handle);
						case 4L:
							switch (ptrArray.Length)
							{
							case 1:
								return new Scalar(ptrArray[0].Handle);
							case 2:
								return (new Scalar(ptrArray[0].Handle), new Scalar(ptrArray[1].Handle));
							case 3:
								return (new Scalar(ptrArray[0].Handle), new Scalar(ptrArray[1].Handle), new Scalar(ptrArray[2].Handle));
							case 4:
								return (new Scalar(ptrArray[0].Handle), new Scalar(ptrArray[1].Handle), new Scalar(ptrArray[2].Handle), new Scalar(ptrArray[3].Handle));
							case 5:
								return (new Scalar(ptrArray[0].Handle), new Scalar(ptrArray[1].Handle), new Scalar(ptrArray[2].Handle), new Scalar(ptrArray[3].Handle), new Scalar(ptrArray[4].Handle));
							default:
							{
								Scalar[] array2 = new Scalar[ptrArray.Length];
								for (int j = 0; j < ptrArray.Length; j++)
								{
									array2[j] = new Scalar(ptrArray[j].Handle);
								}
								return array2;
							}
							}
						case 5L:
						{
							Scalar[] array6 = new Scalar[ptrArray.Length];
							for (int n = 0; n < ptrArray.Length; n++)
							{
								array6[n] = new Scalar(ptrArray[n].Handle);
							}
							return array6;
						}
						case 6L:
						{
							object[] array4 = new object[ptrArray.Length];
							for (int l = 0; l < ptrArray.Length; l++)
							{
								switch (ptrArray[l].TypeCode)
								{
								case 0L:
									array4[l] = new Tensor(ptrArray[l].Handle);
									break;
								case 8L:
									array4[l] = null;
									break;
								case 4L:
									array4[l] = new Scalar(ptrArray[l].Handle);
									break;
								default:
									throw new NotImplementedException("ScriptModule." + name + "() returning something else than a tensor/scalar, a tuple of tensors/scalars, or list of tensors/scalars.");
								}
							}
							return array4;
						}
						case 7L:
							return null;
						case 9L:
							switch (ptrArray.Length)
							{
							case 1:
								return ProcessReturnValue(name, allocator, ptrArray[0]);
							case 2:
								return (ProcessReturnValue(name, allocator, ptrArray[0]), ProcessReturnValue(name, allocator, ptrArray[1]));
							case 3:
								return (ProcessReturnValue(name, allocator, ptrArray[0]), ProcessReturnValue(name, allocator, ptrArray[1]), ProcessReturnValue(name, allocator, ptrArray[2]));
							case 4:
								return (ProcessReturnValue(name, allocator, ptrArray[0]), ProcessReturnValue(name, allocator, ptrArray[1]), ProcessReturnValue(name, allocator, ptrArray[2]), ProcessReturnValue(name, allocator, ptrArray[3]));
							case 5:
								return (ProcessReturnValue(name, allocator, ptrArray[0]), ProcessReturnValue(name, allocator, ptrArray[1]), ProcessReturnValue(name, allocator, ptrArray[2]), ProcessReturnValue(name, allocator, ptrArray[3]), ProcessReturnValue(name, allocator, ptrArray[4]));
							default:
							{
								Scalar[] array3 = new Scalar[ptrArray.Length];
								for (int k = 0; k < ptrArray.Length; k++)
								{
									array3[k] = new Scalar(ptrArray[k].Handle);
								}
								return array3;
							}
							}
						case 8L:
						{
							object[] array = new object[ptrArray.Length];
							for (int i = 0; i < ptrArray.Length; i++)
							{
								array[i] = ProcessReturnValue(name, allocator, ptrArray[i]);
							}
							return array;
						}
						}
					}
					throw new NotImplementedException($"ScriptModule.{name}() returning something else than a tensor, a tuple of tensors, or list of tensors. TypeCode: {typeCode}");
				}

				internal static object ProcessReturnValue(string name, NativeTensorOrScalarIndexedArray allocator, TensorOrScalar value)
				{
					return value.TypeCode switch
					{
						0L => new Tensor(value.Handle), 
						4L => new Scalar(value.Handle), 
						8L => null, 
						_ => ProcessReturnValue(name, allocator, allocator.ToToSArray((int)value.ArrayIndex), value.TypeCode), 
					};
				}

				public TResult invoke<TResult>(string name, params object[] inputs)
				{
					return (TResult)invoke(name, inputs);
				}

				public TResult invoke<T, TResult>(string name, params T[] inputs)
				{
					return (TResult)invoke(name, inputs);
				}
			}

			public class HookableScriptModule<TPreHook, TPostHook> : ScriptModule
			{
				public class HookRemover
				{
					private HookableScriptModule<TPreHook, TPostHook> module;

					private string key;

					public HookRemover(HookableScriptModule<TPreHook, TPostHook> module, string key)
					{
						this.module = module;
						this.key = key;
					}

					public void remove()
					{
						module.remove(key);
					}
				}

				protected Dictionary<string, TPreHook> pre_hooks = new Dictionary<string, TPreHook>();

				protected Dictionary<string, TPostHook> post_hooks = new Dictionary<string, TPostHook>();

				internal HookableScriptModule(IntPtr handle)
					: base(handle)
				{
				}

				public HookRemover register_forward_hook(TPostHook hook)
				{
					string key = Guid.NewGuid().ToString();
					post_hooks.Add(key, hook);
					return new HookRemover(this, key);
				}

				public HookRemover register_forward_pre_hook(TPreHook hook)
				{
					string key = Guid.NewGuid().ToString();
					pre_hooks.Add(key, hook);
					return new HookRemover(this, key);
				}

				private void remove(string key)
				{
					if (pre_hooks.ContainsKey(key))
					{
						pre_hooks.Remove(key);
					}
					if (post_hooks.ContainsKey(key))
					{
						post_hooks.Remove(key);
					}
				}
			}

			public class ScriptModule<TResult> : ScriptModule, nn.IModule<Tensor[], TResult>
			{
				internal ScriptModule(IntPtr handle)
					: base(handle)
				{
				}

				public TResult call(params Tensor[] input)
				{
					return forward(input);
				}

				public TResult forward(params Tensor[] tensor)
				{
					return (TResult)forward((object[])tensor);
				}
			}

			public class ScriptModule<T, TResult> : HookableScriptModule<Func<ScriptModule<T, TResult>, T, T>, Func<ScriptModule<T, TResult>, T, TResult, TResult>>, nn.IModule<T, TResult>
			{
				internal ScriptModule(IntPtr handle)
					: base(handle)
				{
				}

				public TResult call(T input)
				{
					foreach (Func<ScriptModule<T, TResult>, T, T> value in pre_hooks.Values)
					{
						T val = value(this, input);
						if (val != null)
						{
							input = val;
						}
					}
					TResult val2 = forward(input);
					foreach (Func<ScriptModule<T, TResult>, T, TResult, TResult> value2 in post_hooks.Values)
					{
						TResult val3 = value2(this, input, val2);
						if (val3 != null)
						{
							val2 = val3;
						}
					}
					return val2;
				}

				public TResult forward(T tensor)
				{
					return (TResult)forward((object)tensor);
				}
			}

			public class ScriptModule<T1, T2, TResult> : HookableScriptModule<Func<ScriptModule<T1, T2, TResult>, T1, T2, (T1, T2)?>, Func<ScriptModule<T1, T2, TResult>, T1, T2, TResult, TResult>>, nn.IModule<T1, T2, TResult>
			{
				internal ScriptModule(IntPtr handle)
					: base(handle)
				{
				}

				public TResult call(T1 input1, T2 input2)
				{
					foreach (Func<ScriptModule<T1, T2, TResult>, T1, T2, (T1, T2)?> value in pre_hooks.Values)
					{
						(T1, T2)? tuple = value(this, input1, input2);
						if (tuple.HasValue)
						{
							input1 = tuple.Value.Item1;
							input2 = tuple.Value.Item2;
						}
					}
					TResult val = forward(input1, input2);
					foreach (Func<ScriptModule<T1, T2, TResult>, T1, T2, TResult, TResult> value2 in post_hooks.Values)
					{
						TResult val2 = value2(this, input1, input2, val);
						if (val2 != null)
						{
							val = val2;
						}
					}
					return val;
				}

				public TResult forward(T1 input1, T2 input2)
				{
					return (TResult)forward((object)input1, (object)input2);
				}
			}

			public sealed class DynamicType : Type
			{
				internal DynamicType(IntPtr handle)
					: base(handle, TypeKind.AnyType)
				{
					base.handle = new HType(handle, ownsHandle: true, TypeKind.AnyType);
				}
			}

			public sealed class TensorType : Type
			{
				internal TensorType(IntPtr handle)
					: base(handle, TypeKind.TensorType)
				{
					base.handle = new HType(handle, ownsHandle: true, TypeKind.TensorType);
				}

				internal TensorType(Type type)
				{
					handle = type.handle;
					type.handle = new HType(IntPtr.Zero, ownsHandle: true, TypeKind.TensorType);
					type.Dispose();
				}

				public ScalarType GetScalarType()
				{
					return (ScalarType)NativeMethods.THSJIT_TensorType_dtype(handle);
				}

				public long[] size()
				{
					using PinnedArray<long> pinnedArray = new PinnedArray<long>();
					NativeMethods.THSJIT_TensorType_sizes(handle, pinnedArray.CreateArray);
					CheckForErrors();
					return pinnedArray.Array;
				}

				public int GetDimensions()
				{
					return NativeMethods.THSJIT_getDimensionedTensorTypeDimensions(handle);
				}

				public string GetDevice()
				{
					return NativeMethods.THSJIT_getDimensionedTensorDevice(handle);
				}
			}

			public class Type : IDisposable
			{
				internal sealed class HType : SafeHandle
				{
					private TypeKind kind;

					public override bool IsInvalid => handle == IntPtr.Zero;

					public HType(IntPtr preexistingHandle, bool ownsHandle, TypeKind kind)
						: base(IntPtr.Zero, ownsHandle)
					{
						SetHandle(preexistingHandle);
						this.kind = kind;
					}

					internal HType()
						: base(IntPtr.Zero, ownsHandle: true)
					{
					}

					protected override bool ReleaseHandle()
					{
						if (kind == TypeKind.TensorType)
						{
							NativeMethods.THSJIT_TensorType_dispose(this);
						}
						else
						{
							NativeMethods.THSJIT_Type_dispose(this);
						}
						return true;
					}
				}

				internal enum TypeKind : sbyte
				{
					AnyType = 0,
					TensorType = 3
				}

				internal HType handle;

				internal TypeKind Kind => (TypeKind)NativeMethods.THSJIT_Type_kind(handle);

				internal Type(IntPtr handle, TypeKind kind)
				{
					this.handle = new HType(handle, ownsHandle: true, kind);
				}

				protected Type()
				{
				}

				~Type()
				{
					Dispose(disposing: false);
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				protected virtual void Dispose(bool disposing)
				{
					if (disposing)
					{
						handle.Dispose();
						handle.SetHandleAsInvalid();
					}
				}

				internal TensorType AsTensorType()
				{
					return new TensorType(NativeMethods.THSJIT_Type_cast(handle));
				}

				internal DynamicType AsDynamicType()
				{
					return new DynamicType(NativeMethods.THSJIT_Type_cast(handle));
				}
			}

			public static CompilationUnit compile(string script)
			{
				if (string.IsNullOrEmpty(script))
				{
					throw new ArgumentNullException("empty script");
				}
				IntPtr intPtr = NativeMethods.THSJIT_compile(script);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new CompilationUnit(intPtr);
			}

			public static ScriptModule load(string filename, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule(_load(filename, device_type, device_index));
			}

			public static ScriptModule load(byte[] bytes, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule(_load(bytes, device_type, device_index));
			}

			public static ScriptModule load(string filename, Device map_location)
			{
				return new ScriptModule(_load(filename, map_location.type, map_location.index));
			}

			public static ScriptModule load(byte[] bytes, Device map_location)
			{
				return new ScriptModule(_load(bytes, map_location.type, map_location.index));
			}

			public static ScriptModule load(string filename, string map_location)
			{
				return load(filename, new Device(map_location));
			}

			public static ScriptModule load(byte[] bytes, string map_location)
			{
				return load(bytes, new Device(map_location));
			}

			public static ScriptModule<TResult> load<TResult>(string filename, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule<TResult>(_load(filename, device_type, device_index));
			}

			public static ScriptModule<TResult> load<TResult>(byte[] bytes, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule<TResult>(_load(bytes, device_type, device_index));
			}

			public static ScriptModule<TResult> load<TResult>(string filename, Device map_location)
			{
				return new ScriptModule<TResult>(_load(filename, map_location.type, map_location.index));
			}

			public static ScriptModule<TResult> load<TResult>(byte[] bytes, Device map_location)
			{
				return new ScriptModule<TResult>(_load(bytes, map_location.type, map_location.index));
			}

			public static ScriptModule<TResult> load<TResult>(string filename, string map_location)
			{
				return load<TResult>(filename, new Device(map_location));
			}

			public static ScriptModule<TResult> load<TResult>(byte[] bytes, string map_location)
			{
				return load<TResult>(bytes, new Device(map_location));
			}

			public static ScriptModule<T1, TResult> load<T1, TResult>(string filename, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule<T1, TResult>(_load(filename, device_type, device_index));
			}

			public static ScriptModule<T1, TResult> load<T1, TResult>(byte[] bytes, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule<T1, TResult>(_load(bytes, device_type, device_index));
			}

			public static ScriptModule<T1, TResult> load<T1, TResult>(string filename, Device map_location)
			{
				return new ScriptModule<T1, TResult>(_load(filename, map_location.type, map_location.index));
			}

			public static ScriptModule<T1, TResult> load<T1, TResult>(byte[] bytes, Device map_location)
			{
				return new ScriptModule<T1, TResult>(_load(bytes, map_location.type, map_location.index));
			}

			public static ScriptModule<T1, TResult> load<T1, TResult>(string filename, string map_location)
			{
				return load<T1, TResult>(filename, new Device(map_location));
			}

			public static ScriptModule<T1, TResult> load<T1, TResult>(byte[] bytes, string map_location)
			{
				return load<T1, TResult>(bytes, new Device(map_location));
			}

			public static ScriptModule<T1, T2, TResult> load<T1, T2, TResult>(string filename, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule<T1, T2, TResult>(_load(filename, device_type, device_index));
			}

			public static ScriptModule<T1, T2, TResult> load<T1, T2, TResult>(byte[] bytes, DeviceType device_type = DeviceType.CPU, long device_index = -1L)
			{
				return new ScriptModule<T1, T2, TResult>(_load(bytes, device_type, device_index));
			}

			public static ScriptModule<T1, T2, TResult> load<T1, T2, TResult>(string filename, Device map_location)
			{
				return new ScriptModule<T1, T2, TResult>(_load(filename, map_location.type, map_location.index));
			}

			public static ScriptModule<T1, T2, TResult> load<T1, T2, TResult>(byte[] bytes, Device map_location)
			{
				return new ScriptModule<T1, T2, TResult>(_load(bytes, map_location.type, map_location.index));
			}

			public static ScriptModule<T1, T2, TResult> load<T1, T2, TResult>(string filename, string map_location)
			{
				return load<T1, T2, TResult>(filename, new Device(map_location));
			}

			public static ScriptModule<T1, T2, TResult> load<T1, T2, TResult>(byte[] bytes, string map_location)
			{
				return load<T1, T2, TResult>(bytes, new Device(map_location));
			}

			private static IntPtr _load(string filename, DeviceType device_type, long device_index)
			{
				if (!File.Exists(filename))
				{
					throw new FileNotFoundException(filename);
				}
				if (device_type != DeviceType.CUDA)
				{
					device_index = -1L;
				}
				if (device_type == DeviceType.CUDA && !cuda.is_available())
				{
					throw new InvalidOperationException("CUDA is not available.");
				}
				IntPtr intPtr = NativeMethods.THSJIT_load(filename, (long)device_type, device_index);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return intPtr;
			}

			private unsafe static IntPtr _load(byte[] bytes, DeviceType device_type, long device_index)
			{
				if (device_type != DeviceType.CUDA)
				{
					device_index = -1L;
				}
				if (device_type == DeviceType.CUDA && !cuda.is_available())
				{
					throw new InvalidOperationException("CUDA is not available.");
				}
				fixed (byte* ptr = bytes)
				{
					IntPtr intPtr = NativeMethods.THSJIT_load_byte_array((IntPtr)ptr, bytes.LongLength, (long)device_type, device_index);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return intPtr;
				}
			}

			public static void save(ScriptModule module, string filename)
			{
				NativeMethods.THSJIT_save(module.handle, filename);
				CheckForErrors();
			}

			public unsafe static void save(ScriptModule module, byte[] bytes)
			{
				fixed (byte* ptr = bytes)
				{
					NativeMethods.THSJIT_save_byte_array(module.handle, (IntPtr)ptr, bytes.LongLength);
					CheckForErrors();
				}
			}
		}

		public static class linalg
		{
			public enum QRMode
			{
				Reduced,
				Complete,
				R
			}

			public static Tensor cholesky(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_cholesky(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor L, Tensor info) cholesky_ex(Tensor input, bool check_errors = false)
			{
				IntPtr pInfo;
				IntPtr intPtr = NativeMethods.THSLinalg_cholesky_ex(input.Handle, check_errors, out pInfo);
				if (intPtr == IntPtr.Zero || pInfo == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (L: new Tensor(intPtr), info: new Tensor(pInfo));
			}

			public static Tensor cond(Tensor input, int p)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_cond_int(input.Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor cond(Tensor input, double p)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_cond_float(input.Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor cond(Tensor input, string p)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_cond_str(input.Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor cond(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_cond_none(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor cross(Tensor input, Tensor other, long dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_cross(input.Handle, other.Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor det(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_det(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor, Tensor) slogdet(Tensor input)
			{
				IntPtr pLogabsdet;
				IntPtr intPtr = NativeMethods.THSLinalg_slogdet(input.Handle, out pLogabsdet);
				if (intPtr == IntPtr.Zero || pLogabsdet == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (new Tensor(intPtr), new Tensor(pLogabsdet));
			}

			public static Tensor diagonal(Tensor input, int offset = 0, int dim1 = -2, int dim2 = -1)
			{
				return input.diagonal(offset, dim1, dim2);
			}

			public static (Tensor, Tensor) eig(Tensor input)
			{
				IntPtr pEigenvectors;
				IntPtr intPtr = NativeMethods.THSLinalg_eig(input.Handle, out pEigenvectors);
				if (intPtr == IntPtr.Zero || pEigenvectors == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (new Tensor(intPtr), new Tensor(pEigenvectors));
			}

			public static (Tensor, Tensor) eigh(Tensor input, char UPLO = 'L')
			{
				IntPtr pEigenvectors;
				IntPtr intPtr = NativeMethods.THSLinalg_eigh(input.Handle, (byte)UPLO, out pEigenvectors);
				if (intPtr == IntPtr.Zero || pEigenvectors == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (new Tensor(intPtr), new Tensor(pEigenvectors));
			}

			public static Tensor eigvals(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_eigvals(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor eigvalsh(Tensor input, char UPLO = 'L')
			{
				IntPtr intPtr = NativeMethods.THSLinalg_eigvalsh(input.Handle, (byte)UPLO);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor householder_product(Tensor A, Tensor tau)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_householder_product(A.Handle, tau.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor inv(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_inv(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor L, Tensor info) inv_ex(Tensor input, bool check_errors = false)
			{
				IntPtr pInfo;
				IntPtr intPtr = NativeMethods.THSLinalg_cholesky_ex(input.Handle, check_errors, out pInfo);
				if (intPtr == IntPtr.Zero || pInfo == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (L: new Tensor(intPtr), info: new Tensor(pInfo));
			}

			public static (Tensor Solution, Tensor Residuals, Tensor Rank, Tensor SingularValues) lstsq(Tensor input, Tensor other)
			{
				IntPtr pResiduals;
				IntPtr pRank;
				IntPtr pSingularValues;
				IntPtr intPtr = NativeMethods.THSLinalg_lstsq_none(input.Handle, other.Handle, out pResiduals, out pRank, out pSingularValues);
				if (intPtr == IntPtr.Zero || pResiduals == IntPtr.Zero || pRank == IntPtr.Zero || pSingularValues == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (Solution: new Tensor(intPtr), Residuals: new Tensor(pResiduals), Rank: new Tensor(pRank), SingularValues: new Tensor(pSingularValues));
			}

			public static (Tensor P, Tensor L, Tensor U) lu(Tensor input, bool pivot = true)
			{
				IntPtr pL;
				IntPtr pU;
				IntPtr intPtr = NativeMethods.THSLinalg_lu(input.Handle, pivot, out pL, out pU);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (P: new Tensor(intPtr), L: new Tensor(pL), U: new Tensor(pU));
			}

			public static (Tensor LU, Tensor? Pivots) lu_factor(Tensor input, bool pivot = true)
			{
				IntPtr pPivots;
				IntPtr intPtr = NativeMethods.THSLinalg_lu_factor(input.Handle, pivot, out pPivots);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (LU: new Tensor(intPtr), Pivots: (pPivots == IntPtr.Zero) ? null : new Tensor(pPivots));
			}

			public static (Tensor LU, Tensor? Pivots) ldl_factor(Tensor input, bool hermitian = true)
			{
				IntPtr pivots;
				IntPtr intPtr = NativeMethods.THSLinalg_ldl_factor(input.Handle, hermitian, out pivots);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (LU: new Tensor(intPtr), Pivots: (pivots == IntPtr.Zero) ? null : new Tensor(pivots));
			}

			public static (Tensor LU, Tensor? Pivots, Tensor? Info) ldl_factor_ex(Tensor input, bool hermitian = true, bool check_errors = false)
			{
				IntPtr pivots;
				IntPtr info;
				IntPtr intPtr = NativeMethods.THSLinalg_ldl_factor_ex(input.Handle, hermitian, check_errors, out pivots, out info);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (LU: new Tensor(intPtr), Pivots: (pivots == IntPtr.Zero) ? null : new Tensor(pivots), Info: (info == IntPtr.Zero) ? null : new Tensor(info));
			}

			public static Tensor ldl_solve(Tensor LD, Tensor pivots, Tensor B, bool hermitian = false)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_ldl_solve(LD.Handle, pivots.Handle, B.Handle, hermitian);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor Solution, Tensor Residuals, Tensor Rank, Tensor SingularValues) lstsq(Tensor input, Tensor other, double rcond)
			{
				IntPtr pResiduals;
				IntPtr pRank;
				IntPtr pSingularValues;
				IntPtr intPtr = NativeMethods.THSLinalg_lstsq_rcond(input.Handle, other.Handle, rcond, out pResiduals, out pRank, out pSingularValues);
				if (intPtr == IntPtr.Zero || pResiduals == IntPtr.Zero || pRank == IntPtr.Zero || pSingularValues == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (Solution: new Tensor(intPtr), Residuals: new Tensor(pResiduals), Rank: new Tensor(pRank), SingularValues: new Tensor(pSingularValues));
			}

			public static Tensor matrix_exp(Tensor input)
			{
				return input.matrix_exp();
			}

			public unsafe static Tensor matrix_norm(Tensor input, string ord = "fro", long[]? dims = null, bool keepdim = false)
			{
				if (dims == null)
				{
					dims = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_matrix_norm_fronuc(input.Handle, (!(ord == "fro")) ? ((byte)1) : ((byte)0), (IntPtr)ptr, dims.Length, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe static Tensor matrix_norm(Tensor input, double ord, long[]? dims = null, bool keepdim = false)
			{
				if (dims == null)
				{
					dims = new long[2] { -2L, -1L };
				}
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_matrix_norm(input.Handle, ord.ToScalar().Handle, (IntPtr)ptr, dims.Length, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public static Tensor matrix_rank(Tensor input, double? atol = null, double? rtol = null, bool hermitian = false)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_matrix_rank(input.Handle, atol ?? double.NegativeInfinity, atol.HasValue, rtol ?? double.NegativeInfinity, rtol.HasValue, hermitian);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor matrix_rank(Tensor input, Tensor atol, Tensor? rtol = null, bool hermitian = false)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_matrix_rank_tensor(input.Handle, atol?.Handle ?? IntPtr.Zero, rtol?.Handle ?? IntPtr.Zero, hermitian);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor multi_dot(IList<Tensor> tensors)
			{
				if (tensors.Count == 0)
				{
					throw new ArgumentException("tensors");
				}
				if (tensors.Count == 1)
				{
					return tensors[0].alias();
				}
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = NativeMethods.THSLinalg_multi_dot(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor norm(Tensor input, string ord, long[]? dims = null, bool keepdim = false)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_norm_str(input.Handle, ord, (IntPtr)ptr, (dims != null) ? dims.Length : 0, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe static Tensor norm(Tensor input, double ord, long[]? dims = null, bool keepdim = false)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_norm_float(input.Handle, ord, (IntPtr)ptr, (dims != null) ? dims.Length : 0, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe static Tensor norm(Tensor input, int ord, long[]? dims = null, bool keepdim = false)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_norm_int(input.Handle, ord, (IntPtr)ptr, (dims != null) ? dims.Length : 0, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe static Tensor norm(Tensor input, long[]? dims = null, bool keepdim = false)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_norm_opt(input.Handle, (IntPtr)ptr, (dims != null) ? dims.Length : 0, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public static Tensor pinv(Tensor input, double? atol = null, double? rtol = null, bool hermitian = false)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_pinv(input.Handle, atol ?? double.NegativeInfinity, atol.HasValue, rtol ?? double.NegativeInfinity, rtol.HasValue, hermitian);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor pinv(Tensor input, Tensor atol, Tensor? rtol = null, bool hermitian = false)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_pinv_tensor(input.Handle, atol?.Handle ?? IntPtr.Zero, rtol?.Handle ?? IntPtr.Zero, hermitian);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor Q, Tensor R) qr(Tensor input, QRMode mode = QRMode.Reduced)
			{
				IntPtr pR;
				IntPtr intPtr = NativeMethods.THSLinalg_qr(input.Handle, (byte)mode, out pR);
				if (intPtr == IntPtr.Zero || pR == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (Q: new Tensor(intPtr), R: new Tensor(pR));
			}

			public static Tensor solve(Tensor A, Tensor B, bool left = true)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_solve(A.Handle, B.Handle, left);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor result, Tensor info) solve_ex(Tensor A, Tensor B, bool left = true, bool check_errors = false)
			{
				IntPtr infos;
				IntPtr intPtr = NativeMethods.THSLinalg_solve_ex(A.Handle, B.Handle, left, check_errors, out infos);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (result: new Tensor(intPtr), info: new Tensor(infos));
			}

			public static Tensor solve_triangular(Tensor A, Tensor B, bool upper, bool left = true, bool unitriangular = false, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSLinalg_solve_triangular(A.Handle, B.Handle, upper, left, unitriangular) : NativeMethods.THSLinalg_solve_triangular_out(A.Handle, B.Handle, upper, left, unitriangular, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static (Tensor U, Tensor S, Tensor Vh) svd(Tensor input, bool fullMatrices = true)
			{
				IntPtr pS;
				IntPtr pVh;
				IntPtr intPtr = NativeMethods.THSLinalg_svd(input.Handle, fullMatrices, out pS, out pVh);
				if (intPtr == IntPtr.Zero || pS == IntPtr.Zero || pVh == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (U: new Tensor(intPtr), S: new Tensor(pS), Vh: new Tensor(pVh));
			}

			public static Tensor svdvals(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_svdvals(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor tensorinv(Tensor input, long ind)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_tensorinv(input.Handle, ind);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor tensorsolve(Tensor A, Tensor B, long[] dims)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_tensorsolve(A.Handle, B.Handle, (IntPtr)ptr, dims.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe static Tensor vector_norm(Tensor input, double ord = 2.0, long[]? dims = null, bool keepdim = false)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSLinalg_vector_norm(input.Handle, ord.ToScalar().Handle, (IntPtr)ptr, (dims != null) ? dims.Length : 0, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public static Tensor vander(Tensor input, long? N = null)
			{
				if (!N.HasValue)
				{
					N = input.shape[input.ndim - 1];
				}
				IntPtr intPtr = NativeMethods.THSLinalg_vander(input.Handle, N.Value);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor vecdot(Tensor x, Tensor y, long dim = -1L, Tensor? @out = null)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_vecdot(x.Handle, y.Handle, dim, @out?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor lu_solve(Tensor LU, Tensor pivots, Tensor B, bool left = true, bool adjoint = false, Tensor? @out = null)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_lu_solve(B.Handle, LU.Handle, pivots.Handle, left, adjoint, @out?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}
		}

		public static class nn
		{
			public static class functional
			{
				public static Tensor celu(Tensor x, double alpha, bool inplace = false)
				{
					if (!inplace)
					{
						return x.celu(alpha);
					}
					return x.celu_(alpha).alias();
				}

				public static Tensor elu(Tensor x, double alpha, bool inplace = false)
				{
					if (!inplace)
					{
						return x.elu(alpha);
					}
					return x.elu_(alpha).alias();
				}

				public static Tensor gelu(Tensor x, bool inplace)
				{
					if (!inplace)
					{
						return x.gelu();
					}
					return x.gelu_().alias();
				}

				public static Tensor gelu(Tensor x)
				{
					return gelu(x, inplace: false);
				}

				public static Tensor glu(Tensor input, long dim = -1L)
				{
					return input.glu(dim);
				}

				public static Tensor hardshrink(Tensor x, double lambda = 0.5)
				{
					using Scalar scalar = (Scalar)lambda;
					IntPtr intPtr = NativeMethods.THSTensor_hardshrink(x.Handle, scalar.Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Hardshrink(Tensor x, double lambda = 0.5)
				{
					return hardshrink(x, lambda);
				}

				public static Tensor hardsigmoid(Tensor input, bool inplace = false)
				{
					if (!inplace)
					{
						return input.hardsigmoid();
					}
					return input.hardsigmoid_().alias();
				}

				public static Tensor hardswish(Tensor input, bool inplace = false)
				{
					if (!inplace)
					{
						return input.hardswish();
					}
					return input.hardswish_().alias();
				}

				public static Tensor hardtanh(Tensor x, double min_val = -1.0, double max_val = 1.0, bool inplace = false)
				{
					if (!inplace)
					{
						return x.hardtanh(min_val, max_val);
					}
					return x.hardtanh_(min_val, max_val).alias();
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Hardtanh(Tensor x, double min_val = -1.0, double max_val = 1.0, bool inplace = false)
				{
					return hardtanh(x, min_val, max_val, inplace);
				}

				public static Tensor leaky_relu(Tensor input, double negative_slope = 0.01, bool inplace = false)
				{
					if (!inplace)
					{
						return input.leaky_relu(negative_slope);
					}
					return input.leaky_relu_(negative_slope).alias();
				}

				public static Tensor logsigmoid(Tensor x)
				{
					return x.log_sigmoid();
				}

				public static Tensor log_softmax(Tensor x, long dim)
				{
					return special.log_softmax(x, dim);
				}

				public static Tensor mish(Tensor x, bool inplace = false)
				{
					using Tensor tensor = softplus(x);
					using Tensor target = tensor.tanh();
					return inplace ? x.mul_(target).alias() : x.mul(target);
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Mish(Tensor x)
				{
					return mish(x);
				}

				public static Tensor prelu(Tensor input, Tensor weight)
				{
					return input.prelu(weight);
				}

				public static Tensor relu(Tensor x, bool inplace = false)
				{
					if (!inplace)
					{
						return x.relu();
					}
					return x.relu_().alias();
				}

				public static Tensor relu6(Tensor x, bool inplace = false)
				{
					if (!inplace)
					{
						return x.relu6();
					}
					return x.relu6_().alias();
				}

				public static Tensor rrelu(Tensor x, double lower = 0.125, double upper = 1.0 / 3.0, bool inplace = false)
				{
					if (!inplace)
					{
						return x.rrelu(lower, upper);
					}
					return x.rrelu_(lower, upper).alias();
				}

				public static Tensor selu(Tensor x, bool inplace = false)
				{
					if (!inplace)
					{
						return x.selu();
					}
					return x.selu_().alias();
				}

				public static Tensor sigmoid(Tensor x, bool inplace)
				{
					if (!inplace)
					{
						return x.sigmoid();
					}
					return x.sigmoid_().alias();
				}

				public static Tensor sigmoid(Tensor x)
				{
					return sigmoid(x, inplace: false);
				}

				public static Tensor silu(Tensor x, bool inplace = false)
				{
					if (!inplace)
					{
						return x.silu();
					}
					return x.silu_().alias();
				}

				[Obsolete("Incorrect name capitalization", false)]
				public static Tensor SiLU(Tensor x, bool inplace = false)
				{
					return silu(x, inplace);
				}

				public static Tensor softmax(Tensor input, long dim, ScalarType? dtype = null)
				{
					return special.softmax(input, dim, dtype);
				}

				public static Tensor softmax2d(Tensor x)
				{
					return softmax(x, -3L);
				}

				public static Tensor softmin(Tensor x, long dim)
				{
					using Tensor input = -x;
					return softmax(input, dim);
				}

				public static Tensor softplus(Tensor x, double beta = 1.0, double threshold = 20.0)
				{
					return x.softplus(beta, threshold);
				}

				public static Tensor softshrink(Tensor x, double lambda = 0.5)
				{
					using Scalar scalar = (Scalar)lambda;
					IntPtr intPtr = NativeMethods.THSTensor_softshrink(x.Handle, scalar.Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Softshrink(Tensor x, double lambda = 0.5)
				{
					return softshrink(x, lambda);
				}

				public static Tensor softsign(Tensor x, bool inplace = false)
				{
					using Tensor tensor = x.abs();
					using Tensor target = 1 + tensor;
					return inplace ? x.div_(target).alias() : x.div(target);
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Softsign(Tensor x)
				{
					return softsign(x);
				}

				public static Tensor tanh(Tensor x, bool inplace = false)
				{
					if (!inplace)
					{
						return x.tanh();
					}
					return x.tanh_().alias();
				}

				public static Tensor tanhshrink(Tensor x, bool inplace = false)
				{
					using Tensor target = x.tanh();
					return inplace ? x.sub_(target).alias() : x.sub(target);
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Tanhshrink(Tensor x)
				{
					return tanhshrink(x);
				}

				public static Tensor threshold(Tensor x, double threshold, double value, bool inplace = false)
				{
					if (!inplace)
					{
						return x.threshold(threshold, value);
					}
					return x.threshold_(threshold, value).alias();
				}

				[Obsolete("Not using the PyTorch naming convention.", false)]
				public static Tensor Threshold(Tensor x, double threshold, double value, bool inplace = false)
				{
					return functional.threshold(x, threshold, value, inplace);
				}

				public static Tensor alpha_dropout(Tensor input, double p = 0.5, bool training = false, bool inplace = false)
				{
					IntPtr intPtr = NativeMethods.THSNN_alpha_dropout(input.Handle, p, training, inplace);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor bilinear(Tensor input1, Tensor input2, Tensor weight, Tensor? bias = null)
				{
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					IntPtr intPtr = NativeMethods.THSNN_functional_bilinear(input1.Handle, input2.Handle, weight.Handle, bias2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor conv1d(Tensor input, Tensor weight, Tensor? bias = null, long? stride = null, long? padding = null, long? dilation = null, long groups = 1L)
				{
					long[] array = new long[1] { stride ?? 1 };
					long[] array2 = new long[1] { padding.GetValueOrDefault() };
					long[] array3 = new long[1] { dilation ?? 1 };
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							fixed (long* ptr3 = array3)
							{
								IntPtr intPtr = NativeMethods.THSTensor_conv1d(input.Handle, weight.Handle, bias2, (IntPtr)ptr, array.Length, (IntPtr)ptr2, array2.Length, (IntPtr)ptr3, array3.Length, groups);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor conv1d_padding(Tensor input, Tensor weight, Tensor? bias = null, long? stride = null, Padding padding = Padding.Valid, long? dilation = null, long groups = 1L)
				{
					long[] array = new long[1] { stride ?? 1 };
					long[] array2 = new long[1] { dilation ?? 1 };
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							IntPtr intPtr = NativeMethods.THSTensor_conv1d_padding(input.Handle, weight.Handle, bias2, (IntPtr)ptr, array.Length, (int)padding, (IntPtr)ptr2, array2.Length, groups);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor conv2d(Tensor input, Tensor weight, Tensor? bias = null, long[]? strides = null, long[]? padding = null, long[]? dilation = null, long groups = 1L)
				{
					if (strides == null)
					{
						strides = new long[1] { 1L };
					}
					if (padding == null)
					{
						padding = new long[1];
					}
					if (dilation == null)
					{
						dilation = new long[1] { 1L };
					}
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = strides)
					{
						fixed (long* ptr2 = padding)
						{
							fixed (long* ptr3 = dilation)
							{
								IntPtr intPtr = NativeMethods.THSTensor_conv2d(input.Handle, weight.Handle, bias2, (IntPtr)ptr, strides.Length, (IntPtr)ptr2, padding.Length, (IntPtr)ptr3, dilation.Length, groups);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor conv2d_padding(Tensor input, Tensor weight, Tensor? bias = null, long[]? strides = null, Padding padding = Padding.Valid, long[]? dilation = null, long groups = 1L)
				{
					if (strides == null)
					{
						strides = new long[1] { 1L };
					}
					if (dilation == null)
					{
						dilation = new long[1] { 1L };
					}
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = strides)
					{
						fixed (long* ptr2 = dilation)
						{
							IntPtr intPtr = NativeMethods.THSTensor_conv2d_padding(input.Handle, weight.Handle, bias2, (IntPtr)ptr, strides.Length, (int)padding, (IntPtr)ptr2, dilation.Length, groups);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor conv3d(Tensor input, Tensor weight, Tensor? bias = null, long[]? strides = null, long[]? padding = null, long[]? dilation = null, long groups = 1L)
				{
					if (strides == null)
					{
						strides = new long[1] { 1L };
					}
					if (padding == null)
					{
						padding = new long[1];
					}
					if (dilation == null)
					{
						dilation = new long[1] { 1L };
					}
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = strides)
					{
						fixed (long* ptr2 = padding)
						{
							fixed (long* ptr3 = dilation)
							{
								IntPtr intPtr = NativeMethods.THSTensor_conv3d(input.Handle, weight.Handle, bias2, (IntPtr)ptr, strides.Length, (IntPtr)ptr2, padding.Length, (IntPtr)ptr3, dilation.Length, groups);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor conv3d_padding(Tensor input, Tensor weight, Tensor? bias = null, long[]? strides = null, Padding padding = Padding.Valid, long[]? dilation = null, long groups = 1L)
				{
					if (strides == null)
					{
						strides = new long[1] { 1L };
					}
					if (dilation == null)
					{
						dilation = new long[1] { 1L };
					}
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = strides)
					{
						fixed (long* ptr2 = dilation)
						{
							IntPtr intPtr = NativeMethods.THSTensor_conv3d_padding(input.Handle, weight.Handle, bias2, (IntPtr)ptr, strides.Length, (int)padding, (IntPtr)ptr2, dilation.Length, groups);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor conv_transpose1d(Tensor input, Tensor weight, Tensor? bias = null, long? stride = null, long? padding = null, long? output_padding = null, long? dilation = null, long groups = 1L)
				{
					long[] array = new long[1] { stride ?? 1 };
					long[] array2 = new long[1] { padding.GetValueOrDefault() };
					long[] array3 = new long[1] { output_padding.GetValueOrDefault() };
					long[] array4 = new long[1] { dilation ?? 1 };
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							fixed (long* ptr3 = array3)
							{
								fixed (long* ptr4 = array4)
								{
									IntPtr intPtr = NativeMethods.THSTensor_conv_transpose1d(input.Handle, weight.Handle, bias2, (IntPtr)ptr, array.Length, (IntPtr)ptr2, array2.Length, (IntPtr)ptr3, array3.Length, (IntPtr)ptr4, array4.Length, groups);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static Tensor conv_transpose2d(Tensor input, Tensor weight, Tensor? bias = null, long[]? strides = null, long[]? padding = null, long[]? output_padding = null, long[]? dilation = null, long groups = 1L)
				{
					strides = ((strides != null) ? strides : new long[2] { 1L, 1L });
					padding = ((padding == null) ? new long[2] : padding);
					output_padding = ((output_padding == null) ? new long[2] : output_padding);
					dilation = ((dilation != null) ? dilation : new long[2] { 1L, 1L });
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = strides)
					{
						fixed (long* ptr2 = padding)
						{
							fixed (long* ptr3 = output_padding)
							{
								fixed (long* ptr4 = dilation)
								{
									IntPtr intPtr = NativeMethods.THSTensor_conv_transpose2d(input.Handle, weight.Handle, bias2, (IntPtr)ptr, strides.Length, (IntPtr)ptr2, padding.Length, (IntPtr)ptr3, output_padding.Length, (IntPtr)ptr4, dilation.Length, groups);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static Tensor conv_transpose3d(Tensor input, Tensor weight, Tensor? bias = null, long[]? strides = null, long[]? padding = null, long[]? output_padding = null, long[]? dilation = null, long groups = 1L)
				{
					strides = ((strides != null) ? strides : new long[3] { 1L, 1L, 1L });
					padding = ((padding == null) ? new long[3] : padding);
					output_padding = ((output_padding == null) ? new long[3] : output_padding);
					dilation = ((dilation != null) ? dilation : new long[3] { 1L, 1L, 1L });
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					fixed (long* ptr = strides)
					{
						fixed (long* ptr2 = padding)
						{
							fixed (long* ptr3 = output_padding)
							{
								fixed (long* ptr4 = dilation)
								{
									IntPtr intPtr = NativeMethods.THSTensor_conv_transpose3d(input.Handle, weight.Handle, bias2, (IntPtr)ptr, strides.Length, (IntPtr)ptr2, padding.Length, (IntPtr)ptr3, output_padding.Length, (IntPtr)ptr4, dilation.Length, groups);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public static Tensor cosine_similarity(Tensor x1, Tensor x2, long dim = 1L, double eps = 1E-08)
				{
					IntPtr intPtr = NativeMethods.THSNN_cosine_similarity(x1.Handle, x2.Handle, dim, eps);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor dropout(Tensor input, double p = 0.5, bool training = true, bool inplace = false)
				{
					IntPtr intPtr = NativeMethods.THSNN_dropout(input.Handle, p, training, inplace);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor dropout1d(Tensor input, double p = 0.5, bool training = true, bool inplace = false)
				{
					return dropout2d(input.unsqueeze(-1L), p, training, inplace).squeeze(-1L);
				}

				public static Tensor dropout2d(Tensor input, double p = 0.5, bool training = true, bool inplace = false)
				{
					IntPtr intPtr = NativeMethods.THSNN_dropout2d(input.Handle, p, training, inplace);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor dropout3d(Tensor input, double p = 0.5, bool training = true, bool inplace = false)
				{
					IntPtr intPtr = NativeMethods.THSNN_dropout3d(input.Handle, p, training, inplace);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor feature_alpha_dropout(Tensor input, double p = 0.5, bool training = false, bool inplace = false)
				{
					IntPtr intPtr = NativeMethods.THSNN_feature_alpha_dropout(input.Handle, p, training, inplace);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor fold(Tensor input, long output_size, long kernel_size, long dilation = 1L, long padding = 0L, long stride = 1L)
				{
					IntPtr intPtr = NativeMethods.THSNN_fold(input.Handle, output_size, output_size, kernel_size, kernel_size, stride, stride, padding, padding, dilation, dilation);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor fold(Tensor input, (long, long) output_size, (long, long) kernel_size, (long, long)? dilation = null, (long, long)? padding = null, (long, long)? stride = null)
				{
					(long, long) valueOrDefault = dilation.GetValueOrDefault();
					if (!dilation.HasValue)
					{
						valueOrDefault = (1L, 1L);
						dilation = valueOrDefault;
					}
					valueOrDefault = stride.GetValueOrDefault();
					if (!stride.HasValue)
					{
						valueOrDefault = (1L, 1L);
						stride = valueOrDefault;
					}
					valueOrDefault = padding.GetValueOrDefault();
					if (!padding.HasValue)
					{
						valueOrDefault = (0L, 0L);
						padding = valueOrDefault;
					}
					IntPtr intPtr = NativeMethods.THSNN_fold(input.Handle, output_size.Item1, output_size.Item2, kernel_size.Item1, kernel_size.Item2, stride.Value.Item1, stride.Value.Item2, padding.Value.Item1, padding.Value.Item2, dilation.Value.Item1, dilation.Value.Item2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor linear(Tensor input, Tensor weights, Tensor? bias = null)
				{
					IntPtr bias2 = bias?.Handle ?? IntPtr.Zero;
					IntPtr intPtr = NativeMethods.THSNN_functional_linear(input.Handle, weights.Handle, bias2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor binary_cross_entropy_with_logits(Tensor input, Tensor target, Tensor? weight = null, Reduction reduction = Reduction.Mean, Tensor? pos_weights = null)
				{
					IntPtr intPtr = NativeMethods.THSNN_binary_cross_entropy_with_logits(input.Handle, target.Handle, weight?.Handle ?? IntPtr.Zero, (long)reduction, pos_weights?.Handle ?? IntPtr.Zero);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor binary_cross_entropy(Tensor input, Tensor target, Tensor? weight = null, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_binary_cross_entropy(input.Handle, target.Handle, weight?.Handle ?? IntPtr.Zero, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor cross_entropy(Tensor input, Tensor target, Tensor? weight = null, long ignore_index = -100L, Reduction reduction = Reduction.Mean, double label_smoothing = 0.0)
				{
					IntPtr intPtr = NativeMethods.THSNN_cross_entropy(input.Handle, target.Handle, weight?.Handle ?? IntPtr.Zero, ignore_index, hasII: true, (long)reduction, label_smoothing);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor poisson_nll_loss(Tensor input, Tensor target, bool log_input = true, bool full = false, float eps = 1E-08f, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_poisson_loss(input.Handle, target.Handle, log_input, full, eps, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor cosine_embedding_loss(Tensor input1, Tensor input2, Tensor target, double margin = 0.0, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_cosine_embedding_loss(input1.Handle, input2.Handle, target.Handle, margin, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor ctc_loss(Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, long blank = 0L, bool zero_infinity = false, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_ctc_loss(log_probs.Handle, targets.Handle, input_lengths.Handle, target_lengths.Handle, blank, zero_infinity, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor hinge_embedding_loss(Tensor input, Tensor target, double margin = 0.0, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_hinge_embedding_loss(input.Handle, target.Handle, margin, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor huber_loss(Tensor input, Tensor target, double delta = 1.0, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_huber_loss(input.Handle, target.Handle, delta, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor margin_ranking_loss(Tensor input1, Tensor input2, Tensor target, double margin = 0.0, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_margin_ranking_loss(input1.Handle, input2.Handle, target.Handle, margin, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor multi_label_margin_loss(Tensor input, Tensor target, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_multilabel_margin_loss(input.Handle, target.Handle, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor multilabel_soft_margin_loss(Tensor input, Tensor target, Tensor? weight = null, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_multilabel_soft_margin_loss(input.Handle, target.Handle, weight?.Handle ?? IntPtr.Zero, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor multi_margin_loss(Tensor input, Tensor target, int p = 1, double margin = 1.0, Tensor? weight = null, Reduction reduction = Reduction.Mean)
				{
					IntPtr weight2 = weight?.Handle ?? IntPtr.Zero;
					IntPtr intPtr = NativeMethods.THSNN_multi_margin_loss(input.Handle, target.Handle, p, margin, weight2, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor mse_loss(Tensor input, Tensor target, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_mse_loss(input.Handle, target.Handle, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor l1_loss(Tensor input, Tensor target, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_l1_loss(input.Handle, target.Handle, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor nll_loss(Tensor input, Tensor target, Tensor? weight = null, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_nll_loss(input.Handle, target.Handle, weight?.Handle ?? IntPtr.Zero, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor gaussian_nll_loss(Tensor input, Tensor target, Tensor variance, bool full = false, float eps = 1E-06f, Reduction reduction = Reduction.Mean)
				{
					return new GaussianNLLLoss(full, eps, reduction).call(input, target, variance);
				}

				public static Tensor kl_div(Tensor input, Tensor target, bool log_target = true, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_kl_div_loss(input.Handle, target.Handle, (long)reduction, log_target);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor smooth_l1_loss(Tensor input, Tensor target, Reduction reduction = Reduction.Mean, double beta = 1.0)
				{
					IntPtr intPtr = NativeMethods.THSNN_smooth_l1_loss(input.Handle, target.Handle, (long)reduction, beta);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor soft_margin_loss(Tensor input, Tensor target, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_soft_margin_loss(input.Handle, target.Handle, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor triplet_margin_loss(Tensor anchor, Tensor positive, Tensor negative, double margin = 1.0, long p = 2L, double eps = 1E-06, bool swap = false, Reduction reduction = Reduction.Mean)
				{
					IntPtr intPtr = NativeMethods.THSNN_triplet_margin_loss(anchor.Handle, positive.Handle, negative.Handle, margin, p, eps, swap, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor triplet_margin_with_distance_loss(Tensor anchor, Tensor positive, Tensor negative, Func<Tensor, Tensor, Tensor>? distance = null, double margin = 1.0, bool swap = false, Reduction reduction = Reduction.Mean)
				{
					DistanceFunctionNative distance_function = null;
					if (distance != null)
					{
						distance_function = delegate(IntPtr x, IntPtr y)
						{
							Tensor tensor = new Tensor(x);
							Tensor tensor2 = new Tensor(y);
							Tensor tensor3 = distance(tensor, tensor2);
							GC.SuppressFinalize(tensor);
							GC.SuppressFinalize(tensor2);
							GC.SuppressFinalize(tensor3);
							return tensor3.Handle;
						};
					}
					IntPtr intPtr = NativeMethods.THSNN_triplet_margin_with_distance_loss(anchor.Handle, positive.Handle, negative.Handle, distance_function, margin, swap, (long)reduction);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor normalize(Tensor input, double p = 2.0, long dim = 1L, double eps = 1E-12)
				{
					IntPtr intPtr = NativeMethods.THSNN_normalize(input.Handle, p, dim, eps);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor batch_norm(Tensor input, Tensor? running_mean, Tensor? running_var, Tensor? weight = null, Tensor? bias = null, bool training = false, double momentum = 0.1, double eps = 1E-05)
				{
					IntPtr intPtr = NativeMethods.THSNN_batch_norm(input.Handle, running_mean?.Handle ?? IntPtr.Zero, running_var?.Handle ?? IntPtr.Zero, weight?.Handle ?? IntPtr.Zero, bias?.Handle ?? IntPtr.Zero, training, momentum, eps);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor group_norm(Tensor input, long num_groups, Tensor? weight = null, Tensor? bias = null, double eps = 1E-05)
				{
					IntPtr intPtr = NativeMethods.THSNN_group_norm(input.Handle, num_groups, weight?.Handle ?? IntPtr.Zero, bias?.Handle ?? IntPtr.Zero, eps);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor instance_norm(Tensor input, Tensor? running_mean = null, Tensor? running_var = null, Tensor? weight = null, Tensor? bias = null, bool use_input_stats = true, double momentum = 0.1, double eps = 1E-05)
				{
					IntPtr intPtr = NativeMethods.THSNN_instance_norm(input.Handle, running_mean?.Handle ?? IntPtr.Zero, running_var?.Handle ?? IntPtr.Zero, weight?.Handle ?? IntPtr.Zero, bias?.Handle ?? IntPtr.Zero, use_input_stats, momentum, eps);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor layer_norm(Tensor input, long[] normalized_shape, Tensor? weight = null, Tensor? bias = null, double eps = 1E-05)
				{
					IntPtr intPtr;
					fixed (long* normalized_shape2 = normalized_shape)
					{
						intPtr = NativeMethods.THSNN_layer_norm(input.Handle, normalized_shape2, normalized_shape.LongLength, weight?.Handle ?? IntPtr.Zero, bias?.Handle ?? IntPtr.Zero, eps);
					}
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor local_response_norm(Tensor input, long size, double alpha = 0.0001, double beta = 0.75, double k = 1.0)
				{
					if (input.Dimensions < 3)
					{
						throw new ArgumentException($"Invalid number of dimensions for LocalResponseNorm argument: {input.Dimensions}");
					}
					IntPtr intPtr = NativeMethods.THSNN_local_response_norm(input.Handle, size, alpha, beta, k);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor one_hot(Tensor x, long num_classes = -1L)
				{
					if (x.dtype != ScalarType.Int64)
					{
						throw new ArgumentException("OneHot input tensor must have elements of type Int64");
					}
					IntPtr intPtr = NativeMethods.THSNN_one_hot(x.Handle, num_classes);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor pairwise_distance(Tensor input1, Tensor input2, double p = 2.0, double eps = 1E-06, bool keepdim = false)
				{
					IntPtr intPtr = NativeMethods.THSNN_pairwise_distance(input1.Handle, input2.Handle, p, eps, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor pixel_shuffle(Tensor input, long upscale_factor)
				{
					IntPtr intPtr = NativeMethods.THSNN_pixel_shuffle(input.Handle, upscale_factor);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor pixel_unshuffle(Tensor input, long downscale_factor)
				{
					IntPtr intPtr = NativeMethods.THSNN_pixel_unshuffle(input.Handle, downscale_factor);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor adaptive_avg_pool1d(Tensor input, long output_size)
				{
					long[] array = new long[1] { output_size };
					fixed (long* ptr = array)
					{
						IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool1d(input.Handle, (IntPtr)ptr, array.Length);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}

				public unsafe static Tensor adaptive_avg_pool2d(Tensor input, long[] output_size)
				{
					fixed (long* ptr = output_size)
					{
						IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool2d(input.Handle, (IntPtr)ptr, output_size.Length);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}

				public unsafe static Tensor adaptive_avg_pool2d(Tensor input, (long, long) output_size)
				{
					long* ptr = stackalloc long[2] { output_size.Item1, output_size.Item2 };
					IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool2d(input.Handle, (IntPtr)ptr, 2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor adaptive_avg_pool2d(Tensor input, long output_size)
				{
					long* ptr = stackalloc long[2] { output_size, output_size };
					IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool2d(input.Handle, (IntPtr)ptr, 2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor adaptive_avg_pool3d(Tensor input, long[] output_size)
				{
					fixed (long* ptr = output_size)
					{
						IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool3d(input.Handle, (IntPtr)ptr, output_size.Length);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}

				public unsafe static Tensor adaptive_avg_pool3d(Tensor input, (long, long, long) output_size)
				{
					long* ptr = stackalloc long[3] { output_size.Item1, output_size.Item2, output_size.Item3 };
					IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool3d(input.Handle, (IntPtr)ptr, 3);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor adaptive_avg_pool3d(Tensor input, long output_size)
				{
					_ = new long[3] { output_size, output_size, output_size };
					long* ptr = stackalloc long[3] { output_size, output_size, output_size };
					IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool3d(input.Handle, (IntPtr)ptr, 3);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor adaptive_avg_pool3d_backward(Tensor gradInput, Tensor gradOutput, Tensor originalInput)
				{
					IntPtr intPtr = NativeMethods.THSTensor_adaptive_avg_pool3d_backward_out(gradInput.Handle, gradOutput.Handle, originalInput.Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor adaptive_max_pool1d(Tensor input, long output_size)
				{
					(Tensor Values, Tensor Indices) tuple = adaptive_max_pool1d_with_indices(input, output_size);
					tuple.Indices.Dispose();
					return tuple.Values;
				}

				public unsafe static (Tensor Values, Tensor Indices) adaptive_max_pool1d_with_indices(Tensor input, long output_size)
				{
					long[] array = new long[1] { output_size };
					fixed (long* ptr = array)
					{
						IntPtr indices;
						IntPtr intPtr = NativeMethods.THSTensor_adaptive_max_pool1d(input.Handle, (IntPtr)ptr, array.Length, out indices);
						if (intPtr == IntPtr.Zero || indices == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return (Values: new Tensor(intPtr), Indices: new Tensor(indices));
					}
				}

				public static Tensor adaptive_max_pool2d(Tensor input, long[] output_size)
				{
					(Tensor Values, Tensor Indices) tuple = adaptive_max_pool2d_with_indices(input, output_size);
					tuple.Indices.Dispose();
					return tuple.Values;
				}

				public unsafe static (Tensor Values, Tensor Indices) adaptive_max_pool2d_with_indices(Tensor input, long[] output_size)
				{
					fixed (long* ptr = output_size)
					{
						IntPtr indices;
						IntPtr intPtr = NativeMethods.THSTensor_adaptive_max_pool2d(input.Handle, (IntPtr)ptr, output_size.Length, out indices);
						if (intPtr == IntPtr.Zero || indices == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return (Values: new Tensor(intPtr), Indices: new Tensor(indices));
					}
				}

				public static Tensor adaptive_max_pool3d(Tensor input, long[] output_size)
				{
					(Tensor Values, Tensor Indices) tuple = adaptive_max_pool3d_with_indices(input, output_size);
					tuple.Indices.Dispose();
					return tuple.Values;
				}

				public unsafe static (Tensor Values, Tensor Indices) adaptive_max_pool3d_with_indices(Tensor input, long[] output_size)
				{
					fixed (long* ptr = output_size)
					{
						IntPtr indices;
						IntPtr intPtr = NativeMethods.THSTensor_adaptive_max_pool1d(input.Handle, (IntPtr)ptr, output_size.Length, out indices);
						if (intPtr == IntPtr.Zero || indices == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return (Values: new Tensor(intPtr), Indices: new Tensor(indices));
					}
				}

				public unsafe static Tensor avg_pool1d(Tensor input, long kernel_size, long? stride = null, long? padding = null, bool ceil_mode = false, bool count_include_pad = true)
				{
					long[] array = new long[1] { kernel_size };
					long[] array2 = new long[1] { stride ?? kernel_size };
					long[] array3 = new long[1] { padding.GetValueOrDefault() };
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							fixed (long* ptr3 = array3)
							{
								IntPtr intPtr = NativeMethods.THSTensor_avg_pool1d(input.Handle, (IntPtr)ptr, array.Length, (IntPtr)ptr2, array2.Length, (IntPtr)ptr3, array3.Length, ceil_mode, count_include_pad);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor avg_pool2d(Tensor input, long[] kernel_size, long[] stride = null, long[] padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
				{
					stride = ((stride == null) ? kernel_size : stride);
					padding = ((padding == null) ? new long[1] : padding);
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = stride)
						{
							fixed (long* ptr3 = padding)
							{
								IntPtr intPtr = NativeMethods.THSTensor_avg_pool2d(input.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, stride.Length, (IntPtr)ptr3, padding.Length, ceil_mode, count_include_pad, divisor_override.GetValueOrDefault());
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor avg_pool2d(Tensor input, long kernel_size, long? stride = null, long padding = 0L, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
				{
					long num = ((!stride.HasValue) ? kernel_size : stride.Value);
					long* ptr = stackalloc long[2] { kernel_size, kernel_size };
					long* ptr2 = stackalloc long[2] { num, num };
					long* ptr3 = stackalloc long[2] { padding, padding };
					IntPtr intPtr = NativeMethods.THSTensor_avg_pool2d(input.Handle, (IntPtr)ptr, 2, (IntPtr)ptr2, 2, (IntPtr)ptr3, 2, ceil_mode, count_include_pad, divisor_override.GetValueOrDefault());
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor avg_pool2d(Tensor input, (long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
				{
					long num;
					if (!stride.HasValue)
					{
						(num, _) = kernel_size;
					}
					else
					{
						num = stride.Value.Item1;
					}
					long num2 = num;
					long num3 = ((!stride.HasValue) ? kernel_size.Item2 : stride.Value.Item2);
					long num4 = (padding.HasValue ? padding.Value.Item1 : 0);
					long num5 = (padding.HasValue ? padding.Value.Item2 : 0);
					long* ptr = stackalloc long[2] { num2, num3 };
					long* ptr2 = stackalloc long[2] { num4, num5 };
					long* ptr3 = stackalloc long[2] { kernel_size.Item1, kernel_size.Item2 };
					IntPtr intPtr = NativeMethods.THSTensor_avg_pool2d(input.Handle, (IntPtr)ptr3, 2, (IntPtr)ptr, 2, (IntPtr)ptr2, 2, ceil_mode, count_include_pad, divisor_override.GetValueOrDefault());
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor avg_pool2d_backward(Tensor input, Tensor originalInput, long[] kernel_sizes, long[] strides = null, long[] paddings = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
				{
					strides = ((strides != null) ? strides : new long[1] { 1L });
					paddings = ((paddings == null) ? new long[1] : paddings);
					fixed (long* ptr = kernel_sizes)
					{
						fixed (long* ptr2 = strides)
						{
							fixed (long* ptr3 = paddings)
							{
								IntPtr intPtr = NativeMethods.THSTensor_avg_pool2d_backward(input.Handle, originalInput.Handle, (IntPtr)ptr, kernel_sizes.Length, (IntPtr)ptr2, strides.Length, (IntPtr)ptr3, paddings.Length, ceil_mode, count_include_pad, divisor_override.GetValueOrDefault());
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor avg_pool3d(Tensor input, long[] kernel_size, long[] stride = null, long[] padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
				{
					stride = ((stride == null) ? kernel_size : stride);
					padding = ((padding == null) ? new long[1] : padding);
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = stride)
						{
							fixed (long* ptr3 = padding)
							{
								IntPtr intPtr = NativeMethods.THSTensor_avg_pool3d(input.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, stride.Length, (IntPtr)ptr3, padding.Length, ceil_mode, count_include_pad, divisor_override.GetValueOrDefault());
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor avg_pool3d_backward(Tensor input, Tensor originalInput, long[] kernel_sizes, long[] strides = null, long[] paddings = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
				{
					strides = ((strides == null) ? kernel_sizes : strides);
					paddings = ((paddings == null) ? new long[1] : paddings);
					fixed (long* ptr = kernel_sizes)
					{
						fixed (long* ptr2 = strides)
						{
							fixed (long* ptr3 = paddings)
							{
								IntPtr intPtr = NativeMethods.THSTensor_avg_pool3d_backward(input.Handle, originalInput.Handle, (IntPtr)ptr, kernel_sizes.Length, (IntPtr)ptr2, strides.Length, (IntPtr)ptr3, paddings.Length, ceil_mode, count_include_pad, divisor_override.GetValueOrDefault());
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public static Tensor fractional_max_pool2d(Tensor input, long kernel_size, long? output_size = null, double? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[2] { output_size.Value, output_size.Value });
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[2] { output_ratio.Value, output_ratio.Value });
					return fractional_max_pool2d(input, new long[2] { kernel_size, kernel_size }, output_size2, output_ratio2);
				}

				public static Tensor fractional_max_pool2d(Tensor input, (long, long) kernel_size, (long, long)? output_size = null, (double, double)? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[2]
					{
						output_size.Value.Item1,
						output_size.Value.Item2
					});
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[2]
					{
						output_ratio.Value.Item1,
						output_ratio.Value.Item2
					});
					return fractional_max_pool2d(input, new long[2] { kernel_size.Item1, kernel_size.Item2 }, output_size2, output_ratio2);
				}

				public static Tensor fractional_max_pool2d(Tensor input, long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
				{
					(Tensor Values, Tensor Indices) tuple = fractional_max_pool2d_with_indices(input, kernel_size, output_size, output_ratio);
					tuple.Indices.Dispose();
					return tuple.Values;
				}

				public static (Tensor Values, Tensor Indices) fractional_max_pool2d_with_indices(Tensor input, long kernel_size, long? output_size = null, double? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[2] { output_size.Value, output_size.Value });
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[2] { output_ratio.Value, output_ratio.Value });
					return fractional_max_pool2d_with_indices(input, new long[2] { kernel_size, kernel_size }, output_size2, output_ratio2);
				}

				public static (Tensor Values, Tensor Indices) fractional_max_pool2d_with_indices(Tensor input, (long, long) kernel_size, (long, long)? output_size = null, (double, double)? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[2]
					{
						output_size.Value.Item1,
						output_size.Value.Item2
					});
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[2]
					{
						output_ratio.Value.Item1,
						output_ratio.Value.Item2
					});
					return fractional_max_pool2d_with_indices(input, new long[2] { kernel_size.Item1, kernel_size.Item2 }, output_size2, output_ratio2);
				}

				public unsafe static (Tensor Values, Tensor Indices) fractional_max_pool2d_with_indices(Tensor input, long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
				{
					if (kernel_size == null || kernel_size.Length != 2)
					{
						throw new ArgumentException("Kernel size must contain two elements.");
					}
					if (output_size != null && output_size.Length != 2)
					{
						throw new ArgumentException("output_size must contain two elements.");
					}
					if (output_ratio != null && output_ratio.Length != 2)
					{
						throw new ArgumentException("output_ratio must contain two elements.");
					}
					if (output_size == null && output_ratio == null)
					{
						throw new ArgumentNullException("Only one of output_size and output_ratio may be specified.");
					}
					if (output_size != null && output_ratio != null)
					{
						throw new ArgumentNullException("FractionalMaxPool2d requires specifying either an output size, or a pooling ratio.");
					}
					if (output_size == null)
					{
						output_size = Array.Empty<long>();
					}
					if (output_ratio == null)
					{
						output_ratio = Array.Empty<double>();
					}
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = output_size)
						{
							fixed (double* ptr3 = output_ratio)
							{
								IntPtr indices;
								IntPtr intPtr = NativeMethods.THSTensor_fractional_max_pool2d(input.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, output_size.Length, (IntPtr)ptr3, output_ratio.Length, out indices);
								if (intPtr == IntPtr.Zero || indices == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return (Values: new Tensor(intPtr), Indices: new Tensor(indices));
							}
						}
					}
				}

				public static Tensor fractional_max_pool3d(Tensor input, long kernel_size, long? output_size = null, double? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[3] { output_size.Value, output_size.Value, output_size.Value });
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[3] { output_ratio.Value, output_ratio.Value, output_ratio.Value });
					return fractional_max_pool3d(input, new long[3] { kernel_size, kernel_size, kernel_size }, output_size2, output_ratio2);
				}

				public static Tensor fractional_max_pool3d(Tensor input, (long, long, long) kernel_size, (long, long, long)? output_size = null, (double, double, double)? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[3]
					{
						output_size.Value.Item1,
						output_size.Value.Item2,
						output_size.Value.Item3
					});
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[3]
					{
						output_ratio.Value.Item1,
						output_ratio.Value.Item2,
						output_ratio.Value.Item3
					});
					return fractional_max_pool3d(input, new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, output_size2, output_ratio2);
				}

				public static Tensor fractional_max_pool3d(Tensor input, long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
				{
					(Tensor Values, Tensor Indices) tuple = fractional_max_pool3d_with_indices(input, kernel_size, output_size, output_ratio);
					tuple.Indices.Dispose();
					return tuple.Values;
				}

				public static (Tensor Values, Tensor Indices) fractional_max_pool3d_with_indices(Tensor input, long kernel_size, long? output_size = null, double? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[3] { output_size.Value, output_size.Value, output_size.Value });
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[3] { output_ratio.Value, output_ratio.Value, output_ratio.Value });
					return fractional_max_pool3d_with_indices(input, new long[3] { kernel_size, kernel_size, kernel_size }, output_size2, output_ratio2);
				}

				public static (Tensor Values, Tensor Indices) fractional_max_pool3d_with_indices(Tensor input, (long, long, long) kernel_size, (long, long, long)? output_size = null, (double, double, double)? output_ratio = null)
				{
					long[] output_size2 = ((!output_size.HasValue) ? null : new long[3]
					{
						output_size.Value.Item1,
						output_size.Value.Item2,
						output_size.Value.Item3
					});
					double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[3]
					{
						output_ratio.Value.Item1,
						output_ratio.Value.Item2,
						output_ratio.Value.Item3
					});
					return fractional_max_pool3d_with_indices(input, new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, output_size2, output_ratio2);
				}

				public unsafe static (Tensor Values, Tensor Indices) fractional_max_pool3d_with_indices(Tensor input, long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
				{
					if (kernel_size == null || kernel_size.Length != 3)
					{
						throw new ArgumentException("Kernel size must contain three elements.");
					}
					if (output_size != null && output_size.Length != 3)
					{
						throw new ArgumentException("output_size must contain three elements.");
					}
					if (output_ratio != null && output_ratio.Length != 3)
					{
						throw new ArgumentException("output_ratio must contain three elements.");
					}
					if (output_size == null && output_ratio == null)
					{
						throw new ArgumentNullException("Only one of output_size and output_ratio may be specified.");
					}
					if (output_size != null && output_ratio != null)
					{
						throw new ArgumentNullException("FractionalMaxPool3d requires specifying either an output size, or a pooling ratio.");
					}
					if (output_ratio != null && input.ndim != 5)
					{
						throw new ArgumentException("FractionalMaxPool3d: input tensor must have 5 dimensions: [N, C, D, H, W]");
					}
					if (output_size == null)
					{
						output_size = Array.Empty<long>();
					}
					if (output_ratio == null)
					{
						output_ratio = Array.Empty<double>();
					}
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = output_size)
						{
							fixed (double* ptr3 = output_ratio)
							{
								IntPtr indices;
								IntPtr intPtr = NativeMethods.THSTensor_fractional_max_pool3d(input.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, output_size.Length, (IntPtr)ptr3, output_ratio.Length, out indices);
								if (intPtr == IntPtr.Zero || indices == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return (Values: new Tensor(intPtr), Indices: new Tensor(indices));
							}
						}
					}
				}

				public unsafe static Tensor lp_pool1d(Tensor input, double norm_type, long kernel_size, long? stride = null, bool ceil_mode = false)
				{
					long[] array = new long[1] { kernel_size };
					long[] array2 = ((!stride.HasValue) ? Array.Empty<long>() : new long[1] { stride.Value });
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							IntPtr intPtr = NativeMethods.THSTensor_lp_pool1d(input.Handle, norm_type, (IntPtr)ptr, array.Length, (IntPtr)ptr2, array2.Length, ceil_mode);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor lp_pool2d(Tensor input, double norm_type, long[] kernel_size, long[] stride = null, bool ceil_mode = false)
				{
					if (stride == null)
					{
						stride = Array.Empty<long>();
					}
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = stride)
						{
							IntPtr intPtr = NativeMethods.THSTensor_lp_pool2d(input.Handle, norm_type, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, stride.Length, ceil_mode);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public static Tensor lp_pool2d(Tensor input, double norm_type, long kernel_size, long? stride = null, bool ceil_mode = false)
				{
					return lp_pool2d(input, norm_type, new long[2] { kernel_size, kernel_size }, (!stride.HasValue) ? null : new long[2] { stride.Value, stride.Value }, ceil_mode);
				}

				public unsafe static Tensor max_pool1d(Tensor input, long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
				{
					long[] array = new long[1] { kernel_size };
					long[] array2 = new long[1] { stride ?? kernel_size };
					long[] array3 = new long[1] { padding.GetValueOrDefault() };
					long[] array4 = new long[1] { dilation ?? 1 };
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							fixed (long* ptr3 = array3)
							{
								fixed (long* ptr4 = array4)
								{
									IntPtr intPtr = NativeMethods.THSTensor_max_pool1d(input.Handle, (IntPtr)ptr, array.Length, (IntPtr)ptr2, array2.Length, (IntPtr)ptr3, array3.Length, (IntPtr)ptr4, array4.Length, ceil_mode);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static (Tensor output, Tensor indices) max_pool1d_with_indices(Tensor input, long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
				{
					long[] array = new long[1] { kernel_size };
					long[] array2 = new long[1] { stride ?? kernel_size };
					long[] array3 = new long[1] { padding.GetValueOrDefault() };
					long[] array4 = new long[1] { dilation ?? 1 };
					IntPtr[] array5;
					using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
					{
						fixed (long* ptr = array)
						{
							fixed (long* ptr2 = array2)
							{
								fixed (long* ptr3 = array3)
								{
									fixed (long* ptr4 = array4)
									{
										NativeMethods.THSTensor_max_pool1d_with_indices(input.Handle, pinnedArray.CreateArray, (IntPtr)ptr, array.Length, (IntPtr)ptr2, array2.Length, (IntPtr)ptr3, array3.Length, (IntPtr)ptr4, array4.Length, ceil_mode);
										CheckForErrors();
									}
								}
							}
						}
						array5 = pinnedArray.Array;
					}
					return (output: new Tensor(array5[0]), indices: new Tensor(array5[1]));
				}

				public unsafe static Tensor max_pool2d(Tensor input, long[] kernel_size, long[] strides = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
				{
					strides = strides ?? kernel_size;
					padding = padding ?? kernel_size.Select((long x) => 0L).ToArray();
					dilation = dilation ?? kernel_size.Select((long x) => 1L).ToArray();
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = strides)
						{
							fixed (long* ptr3 = padding)
							{
								fixed (long* ptr4 = dilation)
								{
									IntPtr intPtr = NativeMethods.THSTensor_max_pool2d(input.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, strides.Length, (IntPtr)ptr3, padding.Length, (IntPtr)ptr4, dilation.Length, ceil_mode);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static Tensor max_pool2d(Tensor input, long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
				{
					long num = (stride.HasValue ? stride.Value : kernel_size);
					long num2 = (padding.HasValue ? padding.Value : 0);
					long num3 = (dilation.HasValue ? dilation.Value : 1);
					long* ptr = stackalloc long[2] { num, num };
					long* ptr2 = stackalloc long[2] { num2, num2 };
					long* ptr3 = stackalloc long[2] { num3, num3 };
					long* ptr4 = stackalloc long[2] { kernel_size, kernel_size };
					IntPtr intPtr = NativeMethods.THSTensor_max_pool2d(input.Handle, (IntPtr)ptr4, 2, (IntPtr)ptr, 2, (IntPtr)ptr2, 2, (IntPtr)ptr3, 2, ceil_mode);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor max_pool2d(Tensor input, (long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null, (long, long)? dilation = null, bool ceil_mode = false)
				{
					long num;
					if (!stride.HasValue)
					{
						(num, _) = kernel_size;
					}
					else
					{
						num = stride.Value.Item1;
					}
					long num2 = num;
					long num3 = (stride.HasValue ? stride.Value.Item2 : kernel_size.Item2);
					long num4 = (padding.HasValue ? padding.Value.Item1 : 0);
					long num5 = (padding.HasValue ? padding.Value.Item2 : 0);
					long num6 = (dilation.HasValue ? dilation.Value.Item1 : 1);
					long num7 = (dilation.HasValue ? dilation.Value.Item2 : 1);
					long* ptr = stackalloc long[2] { num2, num3 };
					long* ptr2 = stackalloc long[2] { num4, num5 };
					long* ptr3 = stackalloc long[2] { num6, num7 };
					long* ptr4 = stackalloc long[2] { kernel_size.Item1, kernel_size.Item2 };
					IntPtr intPtr = NativeMethods.THSTensor_max_pool2d(input.Handle, (IntPtr)ptr4, 2, (IntPtr)ptr, 2, (IntPtr)ptr2, 2, (IntPtr)ptr3, 2, ceil_mode);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static (Tensor output, Tensor indices) max_pool2d_with_indices(Tensor input, long[] kernel_size, long[] strides = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
				{
					strides = strides ?? kernel_size;
					padding = padding ?? kernel_size.Select((long x) => 0L).ToArray();
					dilation = dilation ?? kernel_size.Select((long x) => 1L).ToArray();
					IntPtr[] array;
					using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
					{
						fixed (long* ptr = kernel_size)
						{
							fixed (long* ptr2 = strides)
							{
								fixed (long* ptr3 = padding)
								{
									fixed (long* ptr4 = dilation)
									{
										NativeMethods.THSTensor_max_pool2d_with_indices(input.Handle, pinnedArray.CreateArray, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, strides.Length, (IntPtr)ptr3, padding.Length, (IntPtr)ptr4, dilation.Length, ceil_mode);
										CheckForErrors();
									}
								}
							}
						}
						array = pinnedArray.Array;
					}
					return (output: new Tensor(array[0]), indices: new Tensor(array[1]));
				}

				public unsafe static Tensor max_pool3d(Tensor input, long[] kernel_size, long[] strides = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
				{
					strides = strides ?? kernel_size;
					padding = padding ?? kernel_size.Select((long x) => 0L).ToArray();
					dilation = dilation ?? kernel_size.Select((long x) => 1L).ToArray();
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = strides)
						{
							fixed (long* ptr3 = padding)
							{
								fixed (long* ptr4 = dilation)
								{
									IntPtr intPtr = NativeMethods.THSTensor_max_pool3d(input.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, strides.Length, (IntPtr)ptr3, padding.Length, (IntPtr)ptr4, dilation.Length, ceil_mode);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static (Tensor output, Tensor indices) max_pool3d_with_indices(Tensor input, long[] kernel_size, long[] strides = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
				{
					strides = strides ?? kernel_size;
					padding = padding ?? kernel_size.Select((long x) => 0L).ToArray();
					dilation = dilation ?? kernel_size.Select((long x) => 1L).ToArray();
					IntPtr[] array;
					using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
					{
						fixed (long* ptr = kernel_size)
						{
							fixed (long* ptr2 = strides)
							{
								fixed (long* ptr3 = padding)
								{
									fixed (long* ptr4 = dilation)
									{
										NativeMethods.THSTensor_max_pool3d_with_indices(input.Handle, pinnedArray.CreateArray, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr2, strides.Length, (IntPtr)ptr3, padding.Length, (IntPtr)ptr4, dilation.Length, ceil_mode);
										CheckForErrors();
									}
								}
							}
						}
						array = pinnedArray.Array;
					}
					return (output: new Tensor(array[0]), indices: new Tensor(array[1]));
				}

				public unsafe static Tensor max_unpool1d(Tensor input, Tensor indices, long kernel_size, long? stride = null, long? padding = null, long[] output_size = null)
				{
					long[] array = new long[1] { kernel_size };
					long[] array2 = ((!stride.HasValue) ? Array.Empty<long>() : new long[1] { stride.Value });
					long[] array3 = ((!padding.HasValue) ? Array.Empty<long>() : new long[1] { padding.Value });
					if (output_size == null)
					{
						output_size = Array.Empty<long>();
					}
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							fixed (long* ptr3 = array3)
							{
								fixed (long* ptr4 = output_size)
								{
									IntPtr intPtr = NativeMethods.THSTensor_max_unpool1d(input.Handle, indices.Handle, (IntPtr)ptr, array.Length, (IntPtr)ptr4, output_size.Length, (IntPtr)ptr3, array3.Length, (IntPtr)ptr2, array2.Length);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static Tensor max_unpool2d(Tensor input, Tensor indices, long[] kernel_size, long[] stride = null, long[] padding = null, long[] output_size = null)
				{
					if (stride == null)
					{
						stride = Array.Empty<long>();
					}
					if (padding == null)
					{
						padding = Array.Empty<long>();
					}
					if (output_size == null)
					{
						output_size = Array.Empty<long>();
					}
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = stride)
						{
							fixed (long* ptr3 = padding)
							{
								fixed (long* ptr4 = output_size)
								{
									IntPtr intPtr = NativeMethods.THSTensor_max_unpool2d(input.Handle, indices.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr4, output_size.Length, (IntPtr)ptr3, padding.Length, (IntPtr)ptr2, stride.Length);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public unsafe static Tensor max_unpool3d(Tensor input, Tensor indices, long[] kernel_size, long[] stride = null, long[] padding = null, long[] output_size = null)
				{
					if (stride == null)
					{
						stride = Array.Empty<long>();
					}
					if (padding == null)
					{
						padding = Array.Empty<long>();
					}
					if (output_size == null)
					{
						output_size = Array.Empty<long>();
					}
					fixed (long* ptr = kernel_size)
					{
						fixed (long* ptr2 = stride)
						{
							fixed (long* ptr3 = padding)
							{
								fixed (long* ptr4 = output_size)
								{
									IntPtr intPtr = NativeMethods.THSTensor_max_unpool3d(input.Handle, indices.Handle, (IntPtr)ptr, kernel_size.Length, (IntPtr)ptr4, output_size.Length, (IntPtr)ptr3, padding.Length, (IntPtr)ptr2, stride.Length);
									if (intPtr == IntPtr.Zero)
									{
										CheckForErrors();
									}
									return new Tensor(intPtr);
								}
							}
						}
					}
				}

				public static Tensor scaled_dot_product_attention(Tensor query, Tensor key, Tensor value, Tensor? attn_mask = null, double p = 0.0, [MarshalAs(UnmanagedType.U1)] bool is_casual = false)
				{
					if (p < 0.0)
					{
						throw new ArgumentException("Dropout probability must be greater than or equal to zero.");
					}
					if (is_casual && (object)attn_mask != null)
					{
						throw new ArgumentException("Casual attention masking cannot pass a mask.");
					}
					IntPtr intPtr = NativeMethods.THSNN_scaled_dot_product_attention(query.Handle, key.Handle, value.Handle, attn_mask?.Handle ?? IntPtr.Zero, p, is_casual);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor unfold(Tensor input, long kernel_size, long dilation = 1L, long padding = 0L, long stride = 1L)
				{
					IntPtr intPtr = NativeMethods.THSNN_unfold(input.Handle, kernel_size, kernel_size, stride, stride, padding, padding, dilation, dilation);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor unfold(Tensor input, (long, long) kernel_size, (long, long)? dilation = null, (long, long)? padding = null, (long, long)? stride = null)
				{
					(long, long) valueOrDefault = dilation.GetValueOrDefault();
					if (!dilation.HasValue)
					{
						valueOrDefault = (1L, 1L);
						dilation = valueOrDefault;
					}
					valueOrDefault = stride.GetValueOrDefault();
					if (!stride.HasValue)
					{
						valueOrDefault = (1L, 1L);
						stride = valueOrDefault;
					}
					valueOrDefault = padding.GetValueOrDefault();
					if (!padding.HasValue)
					{
						valueOrDefault = (0L, 0L);
						padding = valueOrDefault;
					}
					IntPtr intPtr = NativeMethods.THSNN_unfold(input.Handle, kernel_size.Item1, kernel_size.Item2, stride.Value.Item1, stride.Value.Item2, padding.Value.Item1, padding.Value.Item2, dilation.Value.Item1, dilation.Value.Item2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor upsample(Tensor input, long[]? size = null, double[]? scale_factor = null, UpsampleMode mode = UpsampleMode.Nearest, bool align_corners = false)
				{
					return interpolate(input, size, scale_factor, (InterpolationMode)mode, align_corners);
				}

				public unsafe static Tensor upsample_nearest1d(Tensor input, long? outputSize, double? scaleFactor)
				{
					long[] array = ((!outputSize.HasValue) ? null : new long[1] { outputSize.Value });
					int outputSizeLength = (outputSize.HasValue ? 1 : 0);
					double[] obj = ((!scaleFactor.HasValue) ? null : new double[1] { scaleFactor.Value });
					int scaleFactorsLength = (scaleFactor.HasValue ? 1 : 0);
					fixed (long* ptr = array)
					{
						fixed (double* ptr2 = obj)
						{
							IntPtr intPtr = NativeMethods.THSTensor_upsample_nearest1d(input.Handle, (IntPtr)ptr, outputSizeLength, (IntPtr)ptr2, scaleFactorsLength);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor upsample_nearest1d_backward(Tensor grad_output, long? outputSize, long inputSize, double? scaleFactor)
				{
					long[] array = ((!outputSize.HasValue) ? null : new long[1] { outputSize.Value });
					int outputSizeLength = (outputSize.HasValue ? 1 : 0);
					long[] array2 = new long[1] { inputSize };
					double[] obj = ((!scaleFactor.HasValue) ? null : new double[1] { scaleFactor.Value });
					int scaleFactorsLength = (scaleFactor.HasValue ? 1 : 0);
					fixed (long* ptr = array)
					{
						fixed (long* ptr2 = array2)
						{
							fixed (double* ptr3 = obj)
							{
								IntPtr intPtr = NativeMethods.THSTensor_upsample_nearest1d_backward(grad_output.Handle, (IntPtr)ptr, outputSizeLength, (IntPtr)ptr2, array2.Length, (IntPtr)ptr3, scaleFactorsLength);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor upsample_nearest2d(Tensor input, long[]? outputSizes = null, double[]? scaleFactors = null)
				{
					int outputSizeLength = ((outputSizes != null) ? outputSizes.Length : 0);
					int scaleFactorsLength = ((scaleFactors != null) ? scaleFactors.Length : 0);
					fixed (long* ptr = outputSizes)
					{
						fixed (double* ptr2 = scaleFactors)
						{
							IntPtr intPtr = NativeMethods.THSTensor_upsample_nearest2d(input.Handle, (IntPtr)ptr, outputSizeLength, (IntPtr)ptr2, scaleFactorsLength);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor upsample_nearest2d_backward(Tensor grad_output, long[] inputSizes, long[]? outputSizes = null, double[]? scaleFactors = null)
				{
					int outputSizeLength = ((outputSizes != null) ? outputSizes.Length : 0);
					int scaleFactorsLength = ((scaleFactors != null) ? scaleFactors.Length : 0);
					fixed (long* ptr = outputSizes)
					{
						fixed (long* ptr2 = inputSizes)
						{
							fixed (double* ptr3 = scaleFactors)
							{
								IntPtr intPtr = NativeMethods.THSTensor_upsample_nearest2d_backward(grad_output.Handle, (IntPtr)ptr, outputSizeLength, (IntPtr)ptr2, inputSizes.Length, (IntPtr)ptr3, scaleFactorsLength);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor upsample_nearest3d_backward(Tensor grad_output, long[] inputSizes, long[]? outputSizes = null, double[]? scaleFactors = null)
				{
					int outputSizeLength = ((outputSizes != null) ? outputSizes.Length : 0);
					int scaleFactorsLength = ((scaleFactors != null) ? scaleFactors.Length : 0);
					fixed (long* ptr = outputSizes)
					{
						fixed (long* ptr2 = inputSizes)
						{
							fixed (double* ptr3 = scaleFactors)
							{
								IntPtr intPtr = NativeMethods.THSTensor_upsample_nearest3d_backward(grad_output.Handle, (IntPtr)ptr, outputSizeLength, (IntPtr)ptr2, inputSizes.Length, (IntPtr)ptr3, scaleFactorsLength);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								return new Tensor(intPtr);
							}
						}
					}
				}

				public unsafe static Tensor upsample_nearest3d(Tensor input, long[]? outputSizes = null, double[]? scaleFactors = null)
				{
					int outputSizeLength = ((outputSizes != null) ? outputSizes.Length : 0);
					int scaleFactorsLength = ((scaleFactors != null) ? scaleFactors.Length : 0);
					fixed (long* ptr = outputSizes)
					{
						fixed (double* ptr2 = scaleFactors)
						{
							IntPtr intPtr = NativeMethods.THSTensor_upsample_nearest3d(input.Handle, (IntPtr)ptr, outputSizeLength, (IntPtr)ptr2, scaleFactorsLength);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public unsafe static Tensor pad(Tensor input, long[] pad, PaddingModes mode = PaddingModes.Constant, double value = 0.0)
				{
					fixed (long* ptr = pad)
					{
						IntPtr intPtr = NativeMethods.THSNN_pad(input.Handle, (IntPtr)ptr, pad.Length, (byte)mode, value);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}

				public unsafe static Tensor pad(Tensor input, ReadOnlySpan<long> pad, PaddingModes mode = PaddingModes.Constant, double value = 0.0)
				{
					fixed (long* ptr = pad)
					{
						IntPtr intPtr = NativeMethods.THSNN_pad(input.Handle, (IntPtr)ptr, pad.Length, (byte)mode, value);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}

				public unsafe static Tensor pad(Tensor input, (long, long) pad, PaddingModes mode = PaddingModes.Constant, double value = 0.0)
				{
					long* ptr = stackalloc long[2] { pad.Item1, pad.Item2 };
					IntPtr intPtr = NativeMethods.THSNN_pad(input.Handle, (IntPtr)ptr, 2, (byte)mode, value);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor pad(Tensor input, (long, long, long, long) pad, PaddingModes mode = PaddingModes.Constant, double value = 0.0)
				{
					long* ptr = stackalloc long[4] { pad.Item1, pad.Item2, pad.Item3, pad.Item4 };
					IntPtr intPtr = NativeMethods.THSNN_pad(input.Handle, (IntPtr)ptr, 4, (byte)mode, value);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor pad(Tensor input, long pad, PaddingModes mode = PaddingModes.Constant, double value = 0.0)
				{
					int num = (int)input.ndim * 2;
					long* ptr = stackalloc long[num];
					for (int i = 0; i < num; i++)
					{
						ptr[i] = pad;
					}
					IntPtr intPtr = NativeMethods.THSNN_pad(input.Handle, (IntPtr)ptr, num, (byte)mode, value);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static Tensor grid_sample(Tensor input, Tensor grid, GridSampleMode mode = GridSampleMode.Bilinear, GridSamplePaddingMode padding_mode = GridSamplePaddingMode.Zeros, bool? align_corners = null)
				{
					byte align_corners2 = (byte)(align_corners.HasValue ? (align_corners.Value ? 1u : 2u) : 0u);
					IntPtr intPtr = NativeMethods.THSNN_grid_sample(input.Handle, grid.Handle, (byte)mode, (byte)padding_mode, align_corners2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public unsafe static Tensor affine_grid(Tensor theta, long[]? size = null, bool align_corners = false)
				{
					fixed (long* ptr = size)
					{
						IntPtr intPtr = NativeMethods.THSNN_affine_grid(theta.Handle, (IntPtr)ptr, (size != null) ? size.Length : 0, align_corners);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}

				public unsafe static Tensor interpolate(Tensor x, long[]? size = null, double[]? scale_factor = null, InterpolationMode mode = InterpolationMode.Nearest, bool? align_corners = null, bool recompute_scale_factor = false, bool antialias = false)
				{
					fixed (long* ptr = size)
					{
						fixed (double* ptr2 = scale_factor)
						{
							byte align_corners2 = (byte)(align_corners.HasValue ? (align_corners.Value ? 1u : 2u) : 0u);
							IntPtr intPtr = NativeMethods.THSNN_interpolate(x.Handle, (IntPtr)ptr, (size != null) ? size.Length : 0, (IntPtr)ptr2, (scale_factor != null) ? scale_factor.Length : 0, (byte)mode, align_corners2, recompute_scale_factor, antialias);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}

				public static Tensor upsample_bilinear(Tensor x, long[]? size = null, double[]? scale_factor = null, bool align_corners = false)
				{
					using Upsample upsample = Upsample(size, scale_factor, UpsampleMode.Bilinear, align_corners);
					return upsample.call(x);
				}

				public static Tensor upsample_nearest(Tensor x, long[]? size = null, double[]? scale_factor = null, bool align_corners = false)
				{
					using Upsample upsample = Upsample(size, scale_factor, UpsampleMode.Nearest, align_corners);
					return upsample.call(x);
				}
			}

			public static class init
			{
				public enum NonlinearityType
				{
					Linear,
					Conv1D,
					Conv2D,
					Conv3D,
					ConvTranspose1D,
					ConvTranspose2D,
					ConvTranspose3D,
					Sigmoid,
					Tanh,
					ReLU,
					LeakyReLU
				}

				public enum FanInOut
				{
					FanIn,
					FanOut
				}

				public static double calculate_gain(NonlinearityType nonlinearity, double param = 0.0)
				{
					return NativeMethods.THSInit_calculate_gain((long)nonlinearity, param);
				}

				public static Tensor ones_(Tensor tensor)
				{
					NativeMethods.THSInit_ones_(tensor.Handle);
					CheckForErrors();
					return tensor;
				}

				public static Tensor zeros_(Tensor tensor)
				{
					NativeMethods.THSInit_zeros_(tensor.Handle);
					CheckForErrors();
					return tensor;
				}

				public static Tensor dirac_(Tensor tensor)
				{
					NativeMethods.THSInit_dirac_(tensor.Handle);
					CheckForErrors();
					return tensor;
				}

				public static Tensor eye_(Tensor tensor)
				{
					NativeMethods.THSInit_eye_(tensor.Handle);
					CheckForErrors();
					return tensor;
				}

				public static Tensor constant_(Tensor tensor, Scalar val)
				{
					NativeMethods.THSInit_constant_(tensor.Handle, val.Handle);
					CheckForErrors();
					return tensor;
				}

				public static Tensor uniform_(Tensor tensor, double low = 0.0, double high = 1.0, Generator generator = null)
				{
					NativeMethods.THSInit_uniform_(tensor.Handle, low, high);
					CheckForErrors();
					return tensor;
				}

				public static Tensor normal_(Tensor tensor, double mean = 0.0, double std = 1.0, Generator generator = null)
				{
					NativeMethods.THSInit_normal_(tensor.Handle, mean, std);
					CheckForErrors();
					return tensor;
				}

				public static Tensor trunc_normal_(Tensor tensor, double mean = 0.0, double std = 1.0, double a = -2.0, double b = 2.0, Generator generator = null)
				{
					using (no_grad())
					{
						NativeMethods.THSInit_trunc_normal_(tensor.Handle, mean, std, a, b);
						CheckForErrors();
						return tensor;
					}
				}

				public static Tensor orthogonal_(Tensor tensor, double gain = 1.0)
				{
					NativeMethods.THSInit_orthogonal_(tensor.Handle, gain);
					CheckForErrors();
					return tensor;
				}

				public static Tensor sparse_(Tensor tensor, double sparsity, double std = 0.01)
				{
					NativeMethods.THSInit_sparse_(tensor.Handle, sparsity, std);
					CheckForErrors();
					return tensor;
				}

				public static Tensor kaiming_uniform_(Tensor tensor, double a = 0.0, FanInOut mode = FanInOut.FanIn, NonlinearityType nonlinearity = NonlinearityType.LeakyReLU)
				{
					NativeMethods.THSInit_kaiming_uniform_(tensor.Handle, a, (long)mode, (long)nonlinearity);
					CheckForErrors();
					return tensor;
				}

				public static Tensor kaiming_normal_(Tensor tensor, double a = 0.0, FanInOut mode = FanInOut.FanIn, NonlinearityType nonlinearity = NonlinearityType.LeakyReLU)
				{
					NativeMethods.THSInit_kaiming_normal_(tensor.Handle, a, (long)mode, (long)nonlinearity);
					CheckForErrors();
					return tensor;
				}

				public static Tensor xavier_uniform_(Tensor tensor, double gain = 1.0)
				{
					NativeMethods.THSInit_xavier_uniform_(tensor.Handle, gain);
					CheckForErrors();
					return tensor;
				}

				public static Tensor glorot_uniform_(Tensor tensor, double gain = 1.0)
				{
					return xavier_uniform_(tensor, gain);
				}

				public static Tensor xavier_normal_(Tensor tensor, double gain = 1.0)
				{
					NativeMethods.THSInit_xavier_uniform_(tensor.Handle, gain);
					CheckForErrors();
					return tensor;
				}

				public static Tensor glorot_normal_(Tensor tensor, double gain = 1.0)
				{
					return xavier_normal_(tensor, gain);
				}

				public static (long fanIn, long fanOut) CalculateFanInAndFanOut(Tensor tensor)
				{
					long dimensions = tensor.Dimensions;
					if (dimensions < 2)
					{
						throw new ArgumentException("Fan in and fan out can not be computed for tensor with fewer than 2 dimensions");
					}
					long[] shape = tensor.shape;
					if (dimensions == 2)
					{
						return (fanIn: shape[1], fanOut: shape[0]);
					}
					long num = tensor.shape[1];
					long num2 = tensor.shape[0];
					long numberOfElements = tensor[0L, 0L].NumberOfElements;
					return (fanIn: num * numberOfElements, fanOut: num2 * numberOfElements);
				}
			}

			public enum Reduction : long
			{
				None,
				Mean,
				Sum
			}

			public class Module : IDisposable
			{
				protected internal sealed class HType : SafeHandle
				{
					private Action<HType>? _dispose;

					public override bool IsInvalid => handle == IntPtr.Zero;

					public HType(IntPtr preexistingHandle, bool ownsHandle, Action<HType>? dispose = null)
						: base(IntPtr.Zero, ownsHandle)
					{
						_dispose = dispose ?? new Action<HType>(NativeMethods.THSNN_Module_dispose);
						SetHandle(preexistingHandle);
					}

					internal HType()
						: base(IntPtr.Zero, ownsHandle: true)
					{
					}

					protected override bool ReleaseHandle()
					{
						if (!IsInvalid && _dispose != null)
						{
							_dispose(this);
						}
						SetHandle(IntPtr.Zero);
						return true;
					}

					protected override void Dispose(bool disposing)
					{
						if (disposing)
						{
							ReleaseHandle();
						}
					}
				}

				internal HType handle;

				internal BoxedModule? boxedModule;

				protected DeviceType _deviceType;

				protected int _deviceIndex = -1;

				private bool _areComponentsRegistered;

				protected OrderedDict<string, Module> _internal_submodules = new OrderedDict<string, Module>();

				protected OrderedDict<string, (Tensor, bool)> _internal_buffers = new OrderedDict<string, (Tensor, bool)>();

				protected OrderedDict<string, Parameter> _internal_params = new OrderedDict<string, Parameter>();

				private ForwardFunctionC? _forwardNative;

				protected string? name;

				internal BoxedModule BoxedModule
				{
					get
					{
						if (boxedModule == null)
						{
							throw new InvalidOperationException("A Sequential or Loaded module may not be added to a Sequential");
						}
						return boxedModule;
					}
				}

				public virtual bool training
				{
					get
					{
						bool result = NativeMethods.THSNN_Module_is_training(handle);
						CheckForErrors();
						return result;
					}
				}

				internal Module(HType handle, IntPtr? boxedHandle)
				{
					this.handle = handle;
					boxedModule = (boxedHandle.HasValue ? new BoxedModule(boxedHandle.Value) : null);
					if (!handle.IsInvalid)
					{
						register_p_and_b();
					}
				}

				internal Module(IntPtr handle, IntPtr? boxedHandle, bool ownsHandle = true)
				{
					this.handle = new HType(handle, ownsHandle);
					boxedModule = (boxedHandle.HasValue ? new BoxedModule(boxedHandle.Value) : null);
					if (!(handle == IntPtr.Zero))
					{
						register_p_and_b();
					}
				}

				private void register_p_and_b()
				{
					(string, Parameter)[] array = _named_parameters();
					for (int i = 0; i < array.Length; i++)
					{
						var (text, param) = array[i];
						register_parameter(text, param);
					}
					(string, Tensor)[] array2 = _named_buffers();
					for (int i = 0; i < array2.Length; i++)
					{
						var (text2, tensor) = array2[i];
						register_buffer(text2, tensor);
					}
				}

				~Module()
				{
					Dispose(disposing: false);
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				protected virtual void Dispose(bool disposing)
				{
					if (!disposing || handle.IsInvalid)
					{
						return;
					}
					foreach (var item in named_buffers(recurse: false))
					{
						item.buffer.DetachFromDisposeScope().Dispose();
					}
					foreach (var item2 in named_parameters(recurse: false))
					{
						item2.parameter.DetachFromDisposeScope().Dispose();
					}
					foreach (var item3 in named_modules())
					{
						item3.module.Dispose();
					}
					handle.Dispose();
					handle.SetHandleAsInvalid();
					boxedModule?.Dispose();
				}

				protected internal virtual Module _to(Device device, ScalarType dtype, bool non_blocking)
				{
					if (!dtype.IsFloatingPoint() && !dtype.IsComplex())
					{
						throw new ArgumentException("nn.Module.to only accepts floating point or complex types, but got desired dtype=" + dtype);
					}
					if (device.type != DeviceType.CUDA)
					{
						device = new Device(device.type);
					}
					if (device.type == DeviceType.CUDA && !cuda.is_available())
					{
						throw new InvalidOperationException("CUDA is not available.");
					}
					InitializeDeviceType(device.type);
					NativeMethods.THSNN_Module_to_device_dtype(handle, (sbyte)dtype, (long)device.type, device.index, non_blocking);
					CheckForErrors();
					_toEpilog(device, dtype, non_blocking);
					return this;
				}

				protected internal virtual Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
				{
					if (deviceType != DeviceType.CUDA)
					{
						deviceIndex = -1;
					}
					if (deviceType == DeviceType.CUDA && !cuda.is_available())
					{
						throw new InvalidOperationException("CUDA is not available.");
					}
					if (deviceType != _deviceType || deviceIndex != _deviceIndex)
					{
						InitializeDeviceType(deviceType);
						NativeMethods.THSNN_Module_to_device(handle, (long)deviceType, deviceIndex, non_blocking);
						CheckForErrors();
						_toEpilog(deviceType, deviceIndex, non_blocking);
					}
					return this;
				}

				protected internal virtual Module _to(ScalarType dtype, bool non_blocking)
				{
					if (!dtype.IsFloatingPoint() && !dtype.IsComplex())
					{
						throw new ArgumentException("nn.Module.to only accepts floating point or complex types, but got desired dtype=" + dtype);
					}
					NativeMethods.THSNN_Module_to_dtype(handle, (sbyte)dtype, non_blocking);
					CheckForErrors();
					_toEpilog(dtype, non_blocking);
					return this;
				}

				protected void _toEpilog(ScalarType dtype, bool non_blocking)
				{
					_toEpilog(dtype, null, non_blocking);
				}

				protected void _toEpilog(Device device, ScalarType dtype, bool non_blocking)
				{
					_toEpilog(dtype, device, non_blocking);
				}

				protected void _toEpilog(DeviceType deviceType, int deviceIndex, bool non_blocking)
				{
					_toEpilog(null, new Device(deviceType, deviceIndex), non_blocking);
				}

				protected virtual void _toEpilog(ScalarType? dtype, Device? device, bool non_blocking)
				{
					if (!dtype.HasValue && device == null)
					{
						throw new ArgumentNullException("dtype and device are both null,");
					}
					foreach (var item2 in named_children())
					{
						Module item = item2.module;
						if (device == null)
						{
							item._to(dtype.Value, non_blocking);
						}
						else if (!dtype.HasValue)
						{
							item._to(device.type, device.index, non_blocking);
						}
						else
						{
							item._to(device, dtype.Value, non_blocking);
						}
					}
					Dictionary<string, FieldInfo> dictionary = GetFieldsRecursive(GetType(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).ToDictionary((FieldInfo field) => field.ComponentName());
					Dictionary<string, PropertyInfo> dictionary2 = GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).ToDictionary((PropertyInfo prop) => prop.Name);
					foreach (var (key, parameter) in named_parameters(recurse: false).ToList())
					{
						if (!ReplaceParameter(dtype, device, parameter, out Parameter p))
						{
							continue;
						}
						if (dictionary2.TryGetValue(key, out var value))
						{
							value.SetValue(this, p);
							continue;
						}
						parameter?.Dispose();
						ConditionallyRegisterParameter(key, p);
						if (dictionary.TryGetValue(key, out var value2))
						{
							value2.SetValue(this, p);
						}
					}
					foreach (var (key2, buffer) in named_buffers(recurse: false).ToList())
					{
						if (!ReplaceBuffer(dtype, device, buffer, out Tensor result))
						{
							continue;
						}
						if (dictionary2.TryGetValue(key2, out var value3))
						{
							value3.SetValue(this, result);
							continue;
						}
						ConditionallyRegisterBuffer(key2, result);
						if (dictionary.TryGetValue(key2, out var value4))
						{
							value4.SetValue(this, result);
						}
					}
					if (device != null)
					{
						_deviceType = device.type;
						_deviceIndex = device.index;
					}
				}

				protected static bool ReplaceBuffer(ScalarType? dtype, Device? device, Tensor buffer, out Tensor? result)
				{
					result = null;
					if (!buffer.toWillCopy(dtype ?? buffer.dtype, device ?? buffer.device))
					{
						return false;
					}
					ScalarType type = ((dtype.HasValue && (buffer.dtype.IsFloatingPoint() || buffer.dtype.IsComplex())) ? dtype.Value : buffer.dtype);
					result = buffer.to(type, device ?? buffer.device, copy: false, disposeAfter: true).DetachFromDisposeScope();
					return true;
				}

				protected static bool ReplaceParameter(ScalarType? dtype, Device? device, Parameter param, out Parameter? p)
				{
					Tensor grad = param.grad;
					p = null;
					if (!param.toWillCopy(dtype ?? param.dtype, device ?? param.device) && ((object)grad == null || !grad.toWillCopy(dtype ?? param.dtype, device ?? param.device)))
					{
						return false;
					}
					ScalarType type = ((dtype.HasValue && (param.dtype.IsFloatingPoint() || param.dtype.IsComplex())) ? dtype.Value : param.dtype);
					using (no_grad())
					{
						p = new Parameter(param.to(type, device ?? param.device), param.requires_grad);
						p.DetachFromDisposeScope();
						if ((object)grad != null)
						{
							using Tensor grad2 = grad.to(type, device ?? param.device).with_requires_grad(grad.requires_grad);
							p.grad = grad2;
						}
					}
					return true;
				}

				private static IEnumerable<FieldInfo> GetFieldsRecursive(Type type, BindingFlags bindingFlags)
				{
					Type currentType = type;
					HashSet<string> seenFields = new HashSet<string>();
					while (currentType != null && currentType != typeof(object))
					{
						FieldInfo[] fields = currentType.GetFields(bindingFlags);
						FieldInfo[] array = fields;
						foreach (FieldInfo fieldInfo in array)
						{
							if (seenFields.Add(fieldInfo.Name))
							{
								yield return fieldInfo;
							}
						}
						currentType = currentType.BaseType;
					}
				}

				public Module _to(Tensor other, bool non_blocking)
				{
					_to(other.dtype, non_blocking);
					return _to(other.device_type, other.device_index, non_blocking);
				}

				public virtual Module apply(Action<Module> fn)
				{
					foreach (var internal_submodule in _internal_submodules)
					{
						internal_submodule.Item2.apply(fn);
					}
					fn(this);
					return this;
				}

				public virtual void train(bool train = true)
				{
					NativeMethods.THSNN_Module_train(handle, train);
					CheckForErrors();
					foreach (var item in named_children())
					{
						item.module.train(train);
					}
				}

				public virtual void eval()
				{
					train(train: false);
				}

				public virtual void zero_grad(bool set_to_none = true)
				{
					NativeMethods.THSNN_Module_zero_grad(handle, set_to_none);
					CheckForErrors();
					foreach (var item2 in named_parameters())
					{
						Parameter item = item2.parameter;
						using Tensor tensor = item.grad;
						if ((object)tensor != null)
						{
							if (set_to_none)
							{
								item.grad = null;
							}
							else
							{
								tensor.zero_();
							}
						}
					}
				}

				public virtual IEnumerable<(string name, Tensor buffer)> named_buffers(bool recurse = true, bool include_nonpersistent = true)
				{
					HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
					foreach (var internal_buffer in _internal_buffers)
					{
						if (!seen.Contains(internal_buffer.Item2.Item1.handle) && internal_buffer.Item2.Item2)
						{
							seen.Add(internal_buffer.Item2.Item1.handle);
							yield return (name: internal_buffer.Item1, buffer: internal_buffer.Item2.Item1);
						}
					}
					if (!recurse)
					{
						yield break;
					}
					foreach (var (submoduleName, module) in _internal_submodules)
					{
						foreach (var (text, tensor) in module.named_buffers(recurse: true, include_nonpersistent))
						{
							if (!seen.Contains(tensor.handle))
							{
								seen.Add(tensor.handle);
								yield return (name: submoduleName + "." + text, buffer: tensor);
							}
						}
					}
				}

				public virtual IEnumerable<Tensor> buffers(bool recurse = true, bool include_nonpersistent = true)
				{
					return from np in named_buffers(recurse, include_nonpersistent)
						select np.buffer;
				}

				public virtual IEnumerable<(string name, Module module)> named_children()
				{
					return _internal_submodules;
				}

				public virtual IEnumerable<(string name, Module module)> named_modules()
				{
					foreach (var internal_submodule in _internal_submodules)
					{
						yield return internal_submodule;
					}
					foreach (var (submoduleName, module) in _internal_submodules)
					{
						foreach (var (text, item) in module.named_modules())
						{
							yield return (name: submoduleName + "." + text, module: item);
						}
					}
				}

				public virtual IEnumerable<Module> modules()
				{
					return from np in named_modules()
						select np.module;
				}

				public virtual IEnumerable<Module> children()
				{
					return from np in named_children()
						select np.module;
				}

				public virtual Dictionary<string, Tensor> state_dict(Dictionary<string, Tensor>? destination = null, string? prefix = null)
				{
					if (destination == null)
					{
						destination = new Dictionary<string, Tensor>();
					}
					foreach (var item3 in named_parameters())
					{
						string key = (string.IsNullOrEmpty(prefix) ? (item3.name ?? "") : (prefix + "." + item3.name));
						NSExtension.TryAdd(destination, key, item3.parameter);
					}
					foreach (var item4 in named_buffers(recurse: true, include_nonpersistent: false))
					{
						string key2 = (string.IsNullOrEmpty(prefix) ? (item4.name ?? "") : (prefix + "." + item4.name));
						NSExtension.TryAdd(destination, key2, item4.buffer);
					}
					foreach (var internal_submodule in _internal_submodules)
					{
						string item = internal_submodule.Item1;
						Module item2 = internal_submodule.Item2;
						string prefix2 = (string.IsNullOrEmpty(prefix) ? (item ?? "") : (prefix + "." + item));
						item2.state_dict(destination, prefix2);
					}
					return destination;
				}

				public virtual (IList<string> missing_keys, IList<string> unexpected_keyes) load_state_dict(Dictionary<string, Tensor> source, bool strict = true, IList<string>? skip = null)
				{
					List<string> list = new List<string>();
					List<string> list2 = new List<string>();
					if (skip == null)
					{
						skip = Array.Empty<string>();
					}
					Dictionary<string, Tensor> dictionary = state_dict();
					foreach (string key in source.Keys)
					{
						if (!skip.Contains(key) && !dictionary.ContainsKey(key))
						{
							list2.Add(key);
						}
					}
					foreach (string key2 in dictionary.Keys)
					{
						if (!skip.Contains(key2) && !source.ContainsKey(key2))
						{
							list.Add(key2);
						}
					}
					if (strict && (list.Count > 0 || list2.Count > 0))
					{
						throw new InvalidOperationException("The loaded state_dict is not identical to the target dictionary.");
					}
					using (no_grad())
					{
						foreach (string key3 in source.Keys)
						{
							if (!skip.Contains(key3) && dictionary.ContainsKey(key3))
							{
								dictionary[key3].copy_(source[key3]);
							}
						}
						return (missing_keys: list, unexpected_keyes: list2);
					}
				}

				protected virtual (string name, Parameter parameter)[] _named_parameters()
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSNN_Module_get_named_parameters(handle, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return array.Select((IntPtr x, int i) => (Marshal.PtrToStringAnsi(strArray[i]), new Parameter(x))).ToArray();
				}

				protected virtual (string name, Tensor buffer)[] _named_buffers()
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
					NativeMethods.THSNN_Module_get_named_buffers(handle, pinnedArray.CreateArray, pinnedArray2.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					IntPtr[] strArray = pinnedArray2.Array;
					return array.Select((IntPtr x, int i) => (Marshal.PtrToStringAnsi(strArray[i]), new Tensor(x))).ToArray();
				}

				public virtual IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
				{
					HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
					foreach (var internal_param in _internal_params)
					{
						if (!seen.Contains(internal_param.Item2.handle))
						{
							seen.Add(internal_param.Item2.handle);
							yield return internal_param;
						}
					}
					if (!recurse)
					{
						yield break;
					}
					foreach (var (submoduleName, module) in _internal_submodules)
					{
						foreach (var (text, parameter) in module.named_parameters())
						{
							if (!seen.Contains(parameter.handle))
							{
								seen.Add(parameter.handle);
								yield return (name: submoduleName + "." + text, parameter: parameter);
							}
						}
					}
				}

				protected virtual Parameter[] _parameters(bool recurse = true)
				{
					IntPtr[] array;
					using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
					{
						AllocatePinnedArray allocator = pinnedArray.CreateArray;
						NativeMethods.THSNN_Module_get_parameters(handle, allocator, recurse);
						CheckForErrors();
						array = pinnedArray.Array;
					}
					return array.Select((IntPtr x) => new Parameter(x)).ToArray();
				}

				public virtual IEnumerable<Parameter> parameters(bool recurse = true)
				{
					return from np in named_parameters(recurse)
						select np.parameter;
				}

				public virtual bool has_buffer(string target)
				{
					if (_internal_buffers.TryGetValue(target, out (Tensor, bool) _))
					{
						return true;
					}
					string[] splits = target.Split(new char[1] { '.' });
					if (splits.Length <= 1)
					{
						return false;
					}
					foreach (var item in from nc in named_children()
						where nc.name == splits[0]
						select nc)
					{
						if (item.Item2.has_buffer(target.Remove(0, splits[0].Length + 1)))
						{
							return true;
						}
					}
					return false;
				}

				public virtual bool has_parameter(string target)
				{
					if (_internal_params.TryGetValue(target, out Parameter _))
					{
						return true;
					}
					string[] splits = target.Split(new char[1] { '.' });
					if (splits.Length <= 1)
					{
						return false;
					}
					foreach (var item in from nc in named_children()
						where nc.name == splits[0]
						select nc)
					{
						if (item.Item2.has_parameter(target.Remove(0, splits[0].Length + 1)))
						{
							return true;
						}
					}
					return false;
				}

				public virtual Tensor? get_buffer(string target)
				{
					if (target == null)
					{
						throw new ArgumentNullException("target");
					}
					if (_internal_buffers.TryGetValue(target, out (Tensor, bool) value))
					{
						return value.Item1;
					}
					string[] splits = target.Split(new char[1] { '.' });
					if (splits.Length <= 1)
					{
						return null;
					}
					foreach (var item in from nc in named_children()
						where nc.name == splits[0]
						select nc)
					{
						Tensor tensor = item.Item2.get_buffer(target.Remove(0, splits[0].Length + 1));
						if ((object)tensor != null)
						{
							return tensor;
						}
					}
					return null;
				}

				public virtual Parameter? get_parameter(string target)
				{
					if (_internal_params.TryGetValue(target, out Parameter value))
					{
						return value;
					}
					string[] splits = target.Split(new char[1] { '.' });
					if (splits.Length <= 1)
					{
						return null;
					}
					foreach (var item in from nc in named_children()
						where nc.name == splits[0]
						select nc)
					{
						Parameter parameter = item.Item2.get_parameter(target.Remove(0, splits[0].Length + 1));
						if ((object)parameter != null)
						{
							return parameter;
						}
					}
					return null;
				}

				public virtual void register_buffer(string name, Tensor tensor, bool persistent = true)
				{
					if ((object)tensor == null || tensor.handle == IntPtr.Zero)
					{
						throw new ArgumentNullException("tensor", "A null tensor cannot be registered as a buffer.");
					}
					if (!NSExtension.TryAdd(_internal_buffers, name, (tensor, persistent)))
					{
						throw new InvalidOperationException("Tensor " + name + " is already registered.");
					}
				}

				public virtual void register_parameter(string name, Parameter param)
				{
					if ((object)param == null || param.handle == IntPtr.Zero)
					{
						throw new ArgumentNullException("param", "A null tensor cannot be registered as a parameter.");
					}
					if (!NSExtension.TryAdd(_internal_params, name, param))
					{
						throw new InvalidOperationException("Parameter " + name + " is already registered.");
					}
				}

				public void add_module(string name, Module module)
				{
					register_module(name, module);
				}

				public virtual void register_module(string name, Module submodule)
				{
					if (submodule == null || submodule.handle.IsInvalid)
					{
						if (_internal_submodules.ContainsKey(name))
						{
							_internal_submodules.Remove(name);
						}
						return;
					}
					if (name.Contains("."))
					{
						throw new ArgumentException("module name can't contain \".\", got: " + name);
					}
					if (string.IsNullOrEmpty(name))
					{
						throw new ArgumentException("module name can't be empty string \"\"");
					}
					if (_internal_submodules.ContainsKey(name))
					{
						throw new InvalidOperationException("Sub-module " + name + " is already registered.");
					}
					submodule.RegisterComponents();
					_internal_submodules.Add(name, submodule);
				}

				protected void ConditionallyRegisterParameter(string name, Tensor value)
				{
					ConditionallyRegisterParameter(name, value as Parameter);
				}

				protected void ConditionallyRegisterParameter(string name, Parameter? value)
				{
					if ((object)value == null)
					{
						if (_internal_params.ContainsKey(name))
						{
							_internal_params.Remove(name);
						}
						return;
					}
					Parameter parameter;
					if ((object)value != null)
					{
						parameter = value;
					}
					else
					{
						parameter = new Parameter(value);
					}
					Parameter value2 = parameter;
					if (_internal_params.ContainsKey(name))
					{
						_internal_params[name] = value2;
					}
					else
					{
						_internal_params.Add(name, value2);
					}
				}

				protected void ConditionallyRegisterBuffer(string name, Tensor? value, bool persistent = true)
				{
					if ((object)value == null)
					{
						if (_internal_buffers.ContainsKey(name))
						{
							_internal_buffers.Remove(name);
						}
					}
					else if (_internal_buffers.ContainsKey(name))
					{
						_internal_buffers[name] = (value, persistent);
					}
					else
					{
						_internal_buffers.Add(name, (value, persistent));
					}
				}

				public virtual string GetName()
				{
					if (!string.IsNullOrEmpty(name))
					{
						return name;
					}
					string result = NativeMethods.THSNN_Module_name(handle);
					CheckForErrors();
					return result;
				}

				public Module save(string location, IList<string>? skip = null)
				{
					using FileStream output = File.Create(location);
					using BinaryWriter writer = new BinaryWriter(output);
					save(writer, skip);
					return this;
				}

				public Module save(BinaryWriter writer, IList<string>? skip = null)
				{
					Dictionary<string, Tensor> sd = state_dict();
					save_state_dict(writer, sd, skip);
					return this;
				}

				public Module save(Stream stream, IList<string>? skip = null)
				{
					using BinaryWriter writer = new BinaryWriter(stream);
					return save(writer, skip);
				}

				public static void save_state_dict(BinaryWriter writer, Dictionary<string, Tensor> sd, IList<string>? skip = null)
				{
					if (skip != null && skip.Count > 0)
					{
						Dictionary<string, Tensor> dictionary = new Dictionary<string, Tensor>();
						foreach (KeyValuePair<string, Tensor> item in sd.Where<KeyValuePair<string, Tensor>>((KeyValuePair<string, Tensor> kv) => !skip.Contains(kv.Key)))
						{
							dictionary.Add(item.Key, item.Value);
						}
						sd = dictionary;
					}
					writer.Encode(sd.Count);
					foreach (KeyValuePair<string, Tensor> item2 in sd)
					{
						writer.Write(item2.Key);
						item2.Value.Save(writer);
					}
				}

				public virtual Module load(string location, bool strict = true, IList<string>? skip = null, Dictionary<string, bool>? loadedParameters = null)
				{
					if (!File.Exists(location))
					{
						throw new FileNotFoundException(location);
					}
					using FileStream input = File.OpenRead(location);
					using BinaryReader reader = new BinaryReader(input);
					load(reader, strict, skip, loadedParameters);
					return this;
				}

				public virtual Module load(BinaryReader reader, bool strict = true, IList<string>? skip = null, Dictionary<string, bool>? loadedParameters = null)
				{
					if (skip == null)
					{
						skip = Array.Empty<string>();
					}
					DeviceType deviceType = _deviceType;
					int deviceIndex = _deviceIndex;
					if (deviceType != DeviceType.CPU)
					{
						this.cpu();
					}
					try
					{
						Dictionary<string, Tensor> dictionary = state_dict();
						long num = reader.Decode();
						if (num != dictionary.Count && strict)
						{
							throw new ArgumentException($"Mismatched state_dict sizes: expected {dictionary.Count}, but found {num} entries.");
						}
						for (int i = 0; i < num; i++)
						{
							string text = reader.ReadString();
							bool flag = dictionary.ContainsKey(text);
							if (!flag && strict)
							{
								throw new ArgumentException("Mismatched module state names: the target modules does not have a submodule or buffer named '" + text + "'");
							}
							if (flag && !skip.Contains(text))
							{
								TensorExtensionMethods.Load(dictionary[text], reader);
							}
							else
							{
								TensorExtensionMethods.Load(reader, skip: true);
							}
							loadedParameters?.Add(text, flag);
						}
					}
					finally
					{
						if (deviceType != DeviceType.CPU)
						{
							_to(deviceType, deviceIndex, non_blocking: false);
						}
					}
					return this;
				}

				public Module load(Stream stream, bool strict = true, IList<string>? skip = null, Dictionary<string, bool>? loadedParameters = null)
				{
					using BinaryReader reader = new BinaryReader(stream);
					return load(reader, strict, skip, loadedParameters);
				}

				public static Module Create<T>(string path) where T : Module, new()
				{
					return new T().load(path);
				}

				protected Module(string name)
					: this(IntPtr.Zero, IntPtr.Zero)
				{
					this.name = name;
					IntPtr pBoxedModule;
					IntPtr preexistingHandle = NativeMethods.THSNN_custom_module(name, ForwardNative, out pBoxedModule);
					CheckForErrors();
					handle = new HType(preexistingHandle, ownsHandle: true);
					_forwardNative = ForwardNative;
					boxedModule = new BoxedModule(pBoxedModule);
					_init_parameters();
					IntPtr ForwardNative(IntPtr t)
					{
						Tensor tensor = new Tensor(t);
						Tensor tensor2 = ((Module<Tensor, Tensor>)this).call(tensor);
						tensor.DecoupleFromNativeHandle();
						return tensor2.DecoupleFromNativeHandle();
					}
				}

				private void _init_parameters()
				{
					(string, Parameter)[] array = _named_parameters();
					for (int i = 0; i < array.Length; i++)
					{
						var (text, param) = array[i];
						register_parameter(text, param);
					}
				}

				protected virtual void RegisterComponents()
				{
					if (_areComponentsRegistered)
					{
						return;
					}
					foreach (FieldInfo item in GetFieldsRecursive(GetType(), BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
					{
						string key = item.ComponentName();
						if (_internal_submodules.ContainsKey(key) || _internal_params.ContainsKey(key) || _internal_buffers.ContainsKey(key))
						{
							continue;
						}
						object value = item.GetValue(this);
						if (!(value is Module submodule))
						{
							if (!(value is Parameter param))
							{
								if (value is Tensor tensor)
								{
									register_buffer(key, tensor);
								}
							}
							else
							{
								register_parameter(key, param);
							}
						}
						else
						{
							register_module(key, submodule);
						}
					}
					_areComponentsRegistered = true;
				}

				protected static (Device device, ScalarType dtype) GetDefaultDeviceAndType(Device? device = null, ScalarType? dtype = null)
				{
					if (!dtype.HasValue)
					{
						dtype = get_default_dtype();
					}
					if (device == null)
					{
						device = get_default_device();
					}
					return (device: device, dtype: dtype.Value);
				}

				internal T MoveModule<T>(Device? device, ScalarType? dtype) where T : Module
				{
					T val = (T)this;
					if (device == null)
					{
						if (!dtype.HasValue)
						{
							return val;
						}
						return (T)val._to(dtype.Value, non_blocking: false);
					}
					if (!dtype.HasValue)
					{
						return (T)val._to(device.type, device.index, non_blocking: false);
					}
					return (T)val._to(device, dtype.Value, non_blocking: false);
				}

				protected void ClearModules()
				{
					_internal_submodules.clear();
				}
			}

			internal class BoxedModule : IDisposable
			{
				internal sealed class HType : SafeHandle
				{
					public override bool IsInvalid => handle == IntPtr.Zero;

					public HType(IntPtr preexistingHandle, bool ownsHandle)
						: base(IntPtr.Zero, ownsHandle)
					{
						SetHandle(preexistingHandle);
					}

					internal HType()
						: base(IntPtr.Zero, ownsHandle: true)
					{
					}

					protected override bool ReleaseHandle()
					{
						if (!IsInvalid)
						{
							NativeMethods.THSNN_AnyModule_dispose(this);
						}
						handle = IntPtr.Zero;
						return true;
					}

					protected override void Dispose(bool disposing)
					{
						if (disposing)
						{
							ReleaseHandle();
						}
					}
				}

				internal HType handle;

				internal BoxedModule(IntPtr handle)
				{
					this.handle = new HType(handle, ownsHandle: true);
				}

				~BoxedModule()
				{
					Dispose(disposing: false);
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				protected void Dispose(bool disposing)
				{
					if (disposing)
					{
						handle.Dispose();
						handle.SetHandleAsInvalid();
					}
				}
			}

			public interface IModule<T, TResult>
			{
				TResult call(T input1);
			}

			public interface IModule<T1, T2, TResult>
			{
				TResult call(T1 input1, T2 input2);
			}

			public interface IModule<T1, T2, T3, TResult>
			{
				TResult call(T1 input1, T2 input2, T3 input3);
			}

			public interface IModule<T1, T2, T3, T4, TResult>
			{
				TResult call(T1 input1, T2 input2, T3 input3, T4 input4);
			}

			public interface IModule<T1, T2, T3, T4, T5, TResult>
			{
				TResult call(T1 input1, T2 input2, T3 input3, T4 input4, T5 input5);
			}

			public interface IModule<T1, T2, T3, T4, T5, T6, TResult>
			{
				TResult call(T1 input1, T2 input2, T3 input3, T4 input4, T5 input5, T6 input6);
			}

			public class HookableModule<TPreHook, TPostHook> : Module
			{
				public class HookRemover
				{
					private HookableModule<TPreHook, TPostHook> module;

					private string key;

					public HookRemover(HookableModule<TPreHook, TPostHook> module, string key)
					{
						this.module = module;
						this.key = key;
					}

					public void remove()
					{
						module.remove(key);
					}
				}

				protected Dictionary<string, TPreHook> pre_hooks = new Dictionary<string, TPreHook>();

				protected Dictionary<string, TPostHook> post_hooks = new Dictionary<string, TPostHook>();

				protected Dictionary<string, Action<Module>> module_pre_hooks = new Dictionary<string, Action<Module>>();

				protected Dictionary<string, Action<Module>> module_post_hooks = new Dictionary<string, Action<Module>>();

				protected HookableModule(string name)
					: base(name)
				{
				}

				protected HookableModule(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal HookableModule(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public HookRemover register_forward_hook(TPostHook hook)
				{
					string key = Guid.NewGuid().ToString();
					post_hooks.Add(key, hook);
					return new HookRemover(this, key);
				}

				public HookRemover register_forward_pre_hook(TPreHook hook)
				{
					string key = Guid.NewGuid().ToString();
					pre_hooks.Add(key, hook);
					return new HookRemover(this, key);
				}

				public HookRemover register_forward_hook(Action<Module> hook)
				{
					string key = Guid.NewGuid().ToString();
					module_post_hooks.Add(key, hook);
					return new HookRemover(this, key);
				}

				public HookRemover register_forward_pre_hook(Action<Module> hook)
				{
					string key = Guid.NewGuid().ToString();
					module_pre_hooks.Add(key, hook);
					return new HookRemover(this, key);
				}

				private void remove(string key)
				{
					if (pre_hooks.ContainsKey(key))
					{
						pre_hooks.Remove(key);
					}
					if (post_hooks.ContainsKey(key))
					{
						post_hooks.Remove(key);
					}
					if (module_pre_hooks.ContainsKey(key))
					{
						module_pre_hooks.Remove(key);
					}
					if (module_post_hooks.ContainsKey(key))
					{
						module_post_hooks.Remove(key);
					}
				}
			}

			public abstract class Module<T, TResult> : HookableModule<Func<Module<T, TResult>, T, T>, Func<Module<T, TResult>, T, TResult, TResult>>, IModule<T, TResult>
			{
				protected Module(string name)
					: base(name)
				{
				}

				protected Module(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal Module(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public abstract TResult forward(T input);

				public TResult call(T input)
				{
					foreach (Action<Module> value in module_pre_hooks.Values)
					{
						value(this);
					}
					foreach (Func<Module<T, TResult>, T, T> value2 in pre_hooks.Values)
					{
						T val = value2(this, input);
						if (val != null)
						{
							input = val;
						}
					}
					TResult val2 = forward(input);
					foreach (Func<Module<T, TResult>, T, TResult, TResult> value3 in post_hooks.Values)
					{
						TResult val3 = value3(this, input, val2);
						if (val3 != null)
						{
							val2 = val3;
						}
					}
					foreach (Action<Module> value4 in module_post_hooks.Values)
					{
						value4(this);
					}
					return val2;
				}
			}

			public abstract class Module<T1, T2, TResult> : HookableModule<Func<Module<T1, T2, TResult>, T1, T2, (T1, T2)?>, Func<Module<T1, T2, TResult>, T1, T2, TResult, TResult>>, IModule<T1, T2, TResult>
			{
				protected Module(string name)
					: base(name)
				{
				}

				protected Module(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal Module(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public abstract TResult forward(T1 input1, T2 input2);

				public TResult call(T1 input1, T2 input2)
				{
					foreach (Action<Module> value in module_pre_hooks.Values)
					{
						value(this);
					}
					foreach (Func<Module<T1, T2, TResult>, T1, T2, (T1, T2)?> value2 in pre_hooks.Values)
					{
						(T1, T2)? tuple = value2(this, input1, input2);
						if (tuple.HasValue)
						{
							input1 = tuple.Value.Item1;
							input2 = tuple.Value.Item2;
						}
					}
					TResult val = forward(input1, input2);
					foreach (Func<Module<T1, T2, TResult>, T1, T2, TResult, TResult> value3 in post_hooks.Values)
					{
						TResult val2 = value3(this, input1, input2, val);
						if (val2 != null)
						{
							val = val2;
						}
					}
					foreach (Action<Module> value4 in module_post_hooks.Values)
					{
						value4(this);
					}
					return val;
				}
			}

			public abstract class Module<T1, T2, T3, TResult> : HookableModule<Func<Module<T1, T2, T3, TResult>, T1, T2, T3, (T1, T2, T3)?>, Func<Module<T1, T2, T3, TResult>, T1, T2, T3, TResult, TResult>>, IModule<T1, T2, T3, TResult>
			{
				protected Module(string name)
					: base(name)
				{
				}

				protected Module(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal Module(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public abstract TResult forward(T1 input1, T2 input2, T3 input3);

				public TResult call(T1 input1, T2 input2, T3 input3)
				{
					foreach (Action<Module> value in module_pre_hooks.Values)
					{
						value(this);
					}
					foreach (Func<Module<T1, T2, T3, TResult>, T1, T2, T3, (T1, T2, T3)?> value2 in pre_hooks.Values)
					{
						(T1, T2, T3)? tuple = value2(this, input1, input2, input3);
						if (tuple.HasValue)
						{
							input1 = tuple.Value.Item1;
							input2 = tuple.Value.Item2;
							input3 = tuple.Value.Item3;
						}
					}
					TResult val = forward(input1, input2, input3);
					foreach (Func<Module<T1, T2, T3, TResult>, T1, T2, T3, TResult, TResult> value3 in post_hooks.Values)
					{
						TResult val2 = value3(this, input1, input2, input3, val);
						if (val2 != null)
						{
							val = val2;
						}
					}
					foreach (Action<Module> value4 in module_post_hooks.Values)
					{
						value4(this);
					}
					return val;
				}
			}

			public abstract class Module<T1, T2, T3, T4, TResult> : HookableModule<Func<Module<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, (T1, T2, T3, T4)?>, Func<Module<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult, TResult>>, IModule<T1, T2, T3, T4, TResult>
			{
				protected Module(string name)
					: base(name)
				{
				}

				protected Module(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal Module(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public abstract TResult forward(T1 input1, T2 input2, T3 input3, T4 input4);

				public TResult call(T1 input1, T2 input2, T3 input3, T4 input4)
				{
					foreach (Action<Module> value in module_pre_hooks.Values)
					{
						value(this);
					}
					foreach (Func<Module<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, (T1, T2, T3, T4)?> value2 in pre_hooks.Values)
					{
						(T1, T2, T3, T4)? tuple = value2(this, input1, input2, input3, input4);
						if (tuple.HasValue)
						{
							input1 = tuple.Value.Item1;
							input2 = tuple.Value.Item2;
							input3 = tuple.Value.Item3;
							input4 = tuple.Value.Item4;
						}
					}
					TResult val = forward(input1, input2, input3, input4);
					foreach (Func<Module<T1, T2, T3, T4, TResult>, T1, T2, T3, T4, TResult, TResult> value3 in post_hooks.Values)
					{
						TResult val2 = value3(this, input1, input2, input3, input4, val);
						if (val2 != null)
						{
							val = val2;
						}
					}
					foreach (Action<Module> value4 in module_post_hooks.Values)
					{
						value4(this);
					}
					return val;
				}
			}

			public abstract class Module<T1, T2, T3, T4, T5, TResult> : HookableModule<Func<Module<T1, T2, T3, T4, T5, TResult>, T1, T2, T3, T4, T5, (T1, T2, T3, T4, T5)?>, Func<Module<T1, T2, T3, T4, T5, TResult>, T1, T2, T3, T4, T5, TResult, TResult>>, IModule<T1, T2, T3, T4, T5, TResult>
			{
				protected Module(string name)
					: base(name)
				{
				}

				protected Module(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal Module(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public abstract TResult forward(T1 input1, T2 input2, T3 input3, T4 input4, T5 input5);

				public TResult call(T1 input1, T2 input2, T3 input3, T4 input4, T5 input5)
				{
					foreach (Action<Module> value in module_pre_hooks.Values)
					{
						value(this);
					}
					foreach (Func<Module<T1, T2, T3, T4, T5, TResult>, T1, T2, T3, T4, T5, (T1, T2, T3, T4, T5)?> value2 in pre_hooks.Values)
					{
						(T1, T2, T3, T4, T5)? tuple = value2(this, input1, input2, input3, input4, input5);
						if (tuple.HasValue)
						{
							input1 = tuple.Value.Item1;
							input2 = tuple.Value.Item2;
							input3 = tuple.Value.Item3;
							input4 = tuple.Value.Item4;
							input5 = tuple.Value.Item5;
						}
					}
					TResult val = forward(input1, input2, input3, input4, input5);
					foreach (Func<Module<T1, T2, T3, T4, T5, TResult>, T1, T2, T3, T4, T5, TResult, TResult> value3 in post_hooks.Values)
					{
						TResult val2 = value3(this, input1, input2, input3, input4, input5, val);
						if (val2 != null)
						{
							val = val2;
						}
					}
					foreach (Action<Module> value4 in module_post_hooks.Values)
					{
						value4(this);
					}
					return val;
				}
			}

			public abstract class Module<T1, T2, T3, T4, T5, T6, TResult> : HookableModule<Func<Module<T1, T2, T3, T4, T5, T6, TResult>, T1, T2, T3, T4, T5, T6, (T1, T2, T3, T4, T5, T6)?>, Func<Module<T1, T2, T3, T4, T5, T6, TResult>, T1, T2, T3, T4, T5, T6, TResult, TResult>>, IModule<T1, T2, T3, T4, T5, T6, TResult>
			{
				protected Module(string name)
					: base(name)
				{
				}

				protected Module(IntPtr handle, IntPtr boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				internal Module(HType handle, IntPtr? boxedHandle)
					: base(handle, boxedHandle)
				{
				}

				public abstract TResult forward(T1 input1, T2 input2, T3 input3, T4 input4, T5 input5, T6 input6);

				public TResult call(T1 input1, T2 input2, T3 input3, T4 input4, T5 input5, T6 input6)
				{
					foreach (Action<Module> value in module_pre_hooks.Values)
					{
						value(this);
					}
					foreach (Func<Module<T1, T2, T3, T4, T5, T6, TResult>, T1, T2, T3, T4, T5, T6, (T1, T2, T3, T4, T5, T6)?> value2 in pre_hooks.Values)
					{
						(T1, T2, T3, T4, T5, T6)? tuple = value2(this, input1, input2, input3, input4, input5, input6);
						if (tuple.HasValue)
						{
							input1 = tuple.Value.Item1;
							input2 = tuple.Value.Item2;
							input3 = tuple.Value.Item3;
							input4 = tuple.Value.Item4;
							input5 = tuple.Value.Item5;
							input6 = tuple.Value.Item6;
						}
					}
					TResult val = forward(input1, input2, input3, input4, input5, input6);
					foreach (Func<Module<T1, T2, T3, T4, T5, T6, TResult>, T1, T2, T3, T4, T5, T6, TResult, TResult> value3 in post_hooks.Values)
					{
						TResult val2 = value3(this, input1, input2, input3, input4, input5, input6, val);
						if (val2 != null)
						{
							val = val2;
						}
					}
					foreach (Action<Module> value4 in module_post_hooks.Values)
					{
						value4(this);
					}
					return val;
				}
			}

			public enum NonLinearities
			{
				ReLU,
				Tanh
			}

			public enum Activations
			{
				ReLU,
				GELU
			}

			public static class utils
			{
				public static class rnn
				{
					public sealed class PackedSequence : IDisposable
					{
						internal sealed class HType : SafeHandle
						{
							public override bool IsInvalid => handle == IntPtr.Zero;

							public HType(IntPtr preexistingHandle, bool ownsHandle)
								: base(IntPtr.Zero, ownsHandle)
							{
								SetHandle(preexistingHandle);
							}

							internal HType()
								: base(IntPtr.Zero, ownsHandle: true)
							{
							}

							protected override bool ReleaseHandle()
							{
								NativeMethods.THSNN_PackedSequence_dispose(handle);
								handle = IntPtr.Zero;
								return true;
							}
						}

						public readonly Tensor data;

						public readonly Tensor batch_sizes;

						public readonly Tensor sorted_indices;

						public readonly Tensor unsorted_indices;

						private HType handle;

						private DisposeScope? mOwningDisposeScope;

						internal DisposeScope? OwningDisposeScope
						{
							get
							{
								return mOwningDisposeScope;
							}
							set
							{
								mOwningDisposeScope = value;
								batch_sizes.OwningDisposeScope = value;
								data.OwningDisposeScope = value;
								sorted_indices.OwningDisposeScope = value;
								unsorted_indices.OwningDisposeScope = value;
							}
						}

						internal bool IsInvalid => handle.IsInvalid;

						internal HType Handle => handle;

						internal PackedSequence(HType handle)
						{
							this.handle = handle;
							data = new Tensor(NativeMethods.THSNN_PackedSequence_data(handle)).DetachFromDisposeScope();
							batch_sizes = new Tensor(NativeMethods.THSNN_PackedSequence_batch_sizes(handle)).DetachFromDisposeScope();
							sorted_indices = new Tensor(NativeMethods.THSNN_PackedSequence_sorted_indices(handle)).DetachFromDisposeScope();
							unsorted_indices = new Tensor(NativeMethods.THSNN_PackedSequence_unsorted_indices(handle)).DetachFromDisposeScope();
							OwningDisposeScope = DisposeScopeManager.ThreadSingleton.RegisterOnCurrentDisposeScope(this);
						}

						public void Dispose()
						{
							if (handle != null && !handle.IsInvalid)
							{
								data.Dispose();
								batch_sizes.Dispose();
								sorted_indices.Dispose();
								unsorted_indices.Dispose();
								DisposeScopeManager.ThreadSingleton.DisposingOnCurrentScope(this);
								OwningDisposeScope?.MarkAsDisposed(this);
								handle.Dispose();
								handle.SetHandleAsInvalid();
							}
						}

						public PackedSequence MoveToOuterDisposeScope()
						{
							OwningDisposeScope?.MoveToOuter(this);
							return this;
						}

						public PackedSequence DetachFromDisposeScope()
						{
							OwningDisposeScope?.Detach(this);
							return this;
						}

						public PackedSequence MoveToOtherDisposeScope(PackedSequence other)
						{
							return MoveToOtherDisposeScope(other.OwningDisposeScope);
						}

						public PackedSequence MoveToOtherDisposeScope(DisposeScope? other)
						{
							if (OwningDisposeScope == null && other != null)
							{
								other.Attach(this);
							}
							else
							{
								OwningDisposeScope?.MoveToOther(other, this);
							}
							return this;
						}
					}

					public static PackedSequence pack_padded_sequence(Tensor input, Tensor lengths, bool batch_first = false, bool enforce_sorted = true)
					{
						PackedSequence.HType hType = NativeMethods.THSNN_pack_padded_sequence(input.Handle, lengths.Handle, batch_first, enforce_sorted);
						if (hType.IsInvalid)
						{
							CheckForErrors();
						}
						return new PackedSequence(hType);
					}

					public static (Tensor, Tensor) pad_packed_sequence(PackedSequence sequence, bool batch_first = false, double padding_value = 0.0, long? total_length = null)
					{
						long total_length2 = (total_length.HasValue ? total_length.Value : (-1));
						NativeMethods.THSNN_pad_packed_sequence(sequence.Handle, batch_first, padding_value, total_length2, out var res, out var res2);
						if (res == IntPtr.Zero || res2 == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return (new Tensor(res), new Tensor(res2));
					}

					public static Tensor pad_sequence(IEnumerable<Tensor> sequences, bool batch_first = false, double padding_value = 0.0)
					{
						IntPtr[] array = sequences.ToHandleArray();
						IntPtr intPtr = NativeMethods.THSNN_pad_sequence(array, array.Length, batch_first, padding_value);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}

					public static PackedSequence pack_sequence(IEnumerable<Tensor> sequences, bool enforce_sorted = true)
					{
						IntPtr[] array = sequences.ToHandleArray();
						PackedSequence.HType hType = NativeMethods.THSNN_pack_sequence(array, array.Length, enforce_sorted);
						if (hType.IsInvalid)
						{
							CheckForErrors();
						}
						return new PackedSequence(hType);
					}
				}

				public static double clip_grad_norm_(IEnumerable<Parameter> tensors, double max_norm, double norm_type = 2.0)
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					double result = NativeMethods.THSTensor_clip_grad_norm_(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length, max_norm, norm_type);
					CheckForErrors();
					return result;
				}

				public static void clip_grad_value_(IEnumerable<Parameter> tensors, double clip_value)
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					NativeMethods.THSTensor_clip_grad_value_(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length, clip_value);
					CheckForErrors();
				}

				public static Tensor parameters_to_vector(IEnumerable<Parameter> tensors)
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					IntPtr intPtr = NativeMethods.THSTensor_parameters_to_vector(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}

				public static void vector_to_parameters(Tensor vec, IEnumerable<Parameter> tensors)
				{
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					IntPtr tensors2 = pinnedArray.CreateArray(tensors.ToHandleArray());
					NativeMethods.THSTensor_vector_to_parameters(vec.Handle, tensors2, pinnedArray.Array.Length);
					CheckForErrors();
				}

				public static (Parameter weight, Parameter bias) fuse_conv_bn_weights(Tensor conv_w, Tensor? conv_b, Tensor bn_rm, Tensor bn_rv, double bn_eps, Tensor? bn_w, Tensor? bn_b, bool transpose = false)
				{
					using DisposeScope disposeScope = NewDisposeScope();
					ScalarType dtype = conv_w.dtype;
					ScalarType type = conv_b?.dtype ?? dtype;
					if ((object)conv_b == null)
					{
						conv_b = zeros_like(bn_rm);
					}
					if ((object)bn_w == null)
					{
						bn_w = ones_like(bn_rm);
					}
					if ((object)bn_b == null)
					{
						bn_b = zeros_like(bn_rm);
					}
					long[] array = conv_w.shape.Select((long _) => 1L).ToArray();
					if (transpose)
					{
						array[1] = -1L;
					}
					else
					{
						array[0] = -1L;
					}
					Tensor tensor = rsqrt(bn_rv + bn_eps);
					Tensor data = (conv_w * (bn_w * tensor).reshape(array)).to(dtype);
					Tensor data2 = ((conv_b - bn_rm) * tensor * bn_w + bn_b).to(type);
					Parameter first = new Parameter(data, conv_w.requires_grad);
					Parameter second = new Parameter(data2, conv_b.requires_grad);
					return disposeScope.MoveToOuter(first, second);
				}

				public static (Parameter weight, Parameter bias) fuse_linear_bn_weights(Tensor linear_w, Tensor? linear_b, Tensor bn_rm, Tensor bn_rv, double bn_eps, Tensor bn_w, Tensor bn_b)
				{
					using DisposeScope disposeScope = NewDisposeScope();
					if ((object)linear_b == null)
					{
						linear_b = zeros_like(bn_rm);
					}
					Tensor tensor = bn_w * rsqrt(bn_rv + bn_eps);
					Tensor data = linear_w * tensor.unsqueeze(-1L);
					Tensor data2 = (linear_b - bn_rm) * tensor + bn_b;
					Parameter first = new Parameter(data, linear_w.requires_grad);
					Parameter second = new Parameter(data2, linear_b.requires_grad);
					return disposeScope.MoveToOuter(first, second);
				}

				public static Linear fuse_linear_bn_eval(Linear linear, BatchNorm bn)
				{
					if (linear.training || bn.training)
					{
						throw new InvalidOperationException("Fusing operators is valid only for eval mode.");
					}
					var (weight, bias) = fuse_linear_bn_weights(linear.weight, linear.bias, bn.running_mean, bn.running_var, bn.eps, bn.weight, bn.bias);
					return Linear(weight, bias);
				}
			}

			private const double one_eighth = 0.125;

			private const double one_third = 1.0 / 3.0;

			public static CELU CELU(double alpha = 1.0, bool inplace = false)
			{
				return new CELU(alpha, inplace);
			}

			public static ELU ELU(double alpha = 1.0, bool inplace = false)
			{
				return new ELU(alpha, inplace);
			}

			public static GELU GELU()
			{
				return new GELU(inplace: false);
			}

			public static GELU GELU(bool inplace)
			{
				return new GELU(inplace);
			}

			public static GLU GLU(long dim = -1L)
			{
				return new GLU(dim);
			}

			public static Hardshrink Hardshrink(double lambda = 0.5)
			{
				return new Hardshrink(lambda);
			}

			public static Hardsigmoid Hardsigmoid(bool inplace = false)
			{
				return new Hardsigmoid(inplace);
			}

			public static Hardswish Hardswish(bool inplace = false)
			{
				return new Hardswish(inplace);
			}

			public static Hardtanh Hardtanh(double min_val = -1.0, double max_val = 1.0, bool inplace = false)
			{
				return new Hardtanh(min_val, max_val, inplace);
			}

			public static LeakyReLU LeakyReLU(double negative_slope = 0.01, bool inplace = false)
			{
				return new LeakyReLU(negative_slope, inplace);
			}

			public static LogSigmoid LogSigmoid()
			{
				return new LogSigmoid();
			}

			public static LogSoftmax LogSoftmax(long dim)
			{
				return new LogSoftmax(dim);
			}

			public static Mish Mish()
			{
				return new Mish(inplace: false);
			}

			public static Mish Mish(bool inplace)
			{
				return new Mish(inplace);
			}

			public static PReLU PReLU(long num_parameters, double init = 0.25, Device? device = null, ScalarType? dtype = null)
			{
				return new PReLU(num_parameters, init).MoveModule<PReLU>(device, dtype);
			}

			public static ReLU ReLU(bool inplace = false)
			{
				return new ReLU(inplace);
			}

			public static ReLU6 ReLU6(bool inplace = false)
			{
				return new ReLU6(inplace);
			}

			public static RReLU RReLU(double lower = 0.125, double upper = 1.0 / 3.0, bool inplace = false)
			{
				return new RReLU(lower, upper, inplace);
			}

			public static SELU SELU(bool inplace = false)
			{
				return new SELU(inplace);
			}

			public static Sigmoid Sigmoid()
			{
				return new Sigmoid(inplace: false);
			}

			public static Sigmoid Sigmoid(bool inplace)
			{
				return new Sigmoid(inplace);
			}

			public static SiLU SiLU()
			{
				return new SiLU(inplace: false);
			}

			public static SiLU SiLU(bool inplace)
			{
				return new SiLU(inplace);
			}

			public static Softmax Softmax(long dim)
			{
				return new Softmax(dim);
			}

			public static Softmax2d Softmax2d()
			{
				return new Softmax2d();
			}

			public static Softmin Softmin(long dim)
			{
				return new Softmin(dim);
			}

			public static Softplus Softplus(double beta = 1.0, double threshold = 20.0)
			{
				return new Softplus(beta, threshold);
			}

			public static Softshrink Softshrink(double lambda = 0.5)
			{
				return new Softshrink(lambda);
			}

			public static Softsign Softsign()
			{
				return new Softsign(inplace: false);
			}

			public static Softsign Softsign(bool inplace)
			{
				return new Softsign(inplace);
			}

			public static Tanh Tanh()
			{
				return new Tanh(inplace: false);
			}

			public static Tanh Tanh(bool inplace = false)
			{
				return new Tanh(inplace);
			}

			public static Tanhshrink Tanhshrink()
			{
				return new Tanhshrink(inplace: false);
			}

			public static Tanhshrink Tanhshrink(bool inplace = false)
			{
				return new Tanhshrink(inplace);
			}

			public static Threshold Threshold(double threshold, double value, bool inplace = false)
			{
				return new Threshold(threshold, value, inplace);
			}

			public static AlphaDropout AlphaDropout(double p = 0.5, bool inplace = false)
			{
				return new AlphaDropout(p, inplace);
			}

			public static Bilinear Bilinear(long in1_features, long in2_features, long out_features, bool hasBias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Bilinear(in1_features, in2_features, out_features, hasBias, device, dtype);
			}

			public static Conv1d Conv1d(long in_channels, long out_channels, long kernel_size, long stride = 1L, long padding = 0L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Conv1d(in_channels, out_channels, kernel_size, stride, padding, null, dilation, groups, bias, padding_mode, device, dtype);
			}

			public static Conv1d Conv1d(long in_channels, long out_channels, long kernel_size, Padding padding, long stride = 1L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Conv1d(in_channels, out_channels, kernel_size, stride, null, padding, dilation, groups, bias, padding_mode, device, dtype);
			}

			public static Conv2d Conv2d(long in_channels, long out_channels, long kernel_size, long stride = 1L, long padding = 0L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Conv2d(in_channels, out_channels, (kernel_size, kernel_size), (stride, stride), (padding, padding), null, (dilation, dilation), groups, bias, padding_mode, device, dtype);
			}

			public static Conv2d Conv2d(long in_channels, long out_channels, (long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null, (long, long)? dilation = null, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				(long, long) valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = padding.GetValueOrDefault();
				if (!padding.HasValue)
				{
					valueOrDefault = (0L, 0L);
					padding = valueOrDefault;
				}
				valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L);
					dilation = valueOrDefault;
				}
				return new Conv2d(in_channels, out_channels, kernel_size, stride.Value, padding, null, dilation.Value, groups, bias, padding_mode, device, dtype);
			}

			public static Conv2d Conv2d(long in_channels, long out_channels, long kernel_size, Padding padding, long stride = 1L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Conv2d(in_channels, out_channels, (kernel_size, kernel_size), (stride, stride), null, padding, (dilation, dilation), groups, bias, padding_mode, device, dtype);
			}

			public static Conv2d Conv2d(long in_channels, long out_channels, (long, long) kernel_size, Padding padding, (long, long)? stride = null, (long, long)? dilation = null, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				(long, long) valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L);
					dilation = valueOrDefault;
				}
				return new Conv2d(in_channels, out_channels, kernel_size, stride.Value, null, padding, dilation.Value, groups, bias, padding_mode, device, dtype);
			}

			public static Conv3d Conv3d(long in_channels, long out_channels, long kernel_size, long stride = 1L, long padding = 0L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Conv3d(in_channels, out_channels, (kernel_size, kernel_size, kernel_size), (stride, stride, stride), (padding, padding, padding), null, (dilation, dilation, dilation), groups, bias, padding_mode, device, dtype);
			}

			public static Conv3d Conv3d(long in_channels, long out_channels, (long, long, long) kernel_size, (long, long, long)? stride = null, (long, long, long)? padding = null, (long, long, long)? dilation = null, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				(long, long, long) valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = padding.GetValueOrDefault();
				if (!padding.HasValue)
				{
					valueOrDefault = (0L, 0L, 0L);
					padding = valueOrDefault;
				}
				valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L, 1L);
					dilation = valueOrDefault;
				}
				return new Conv3d(in_channels, out_channels, kernel_size, stride.Value, padding, null, dilation.Value, groups, bias, padding_mode, device, dtype);
			}

			public static Conv3d Conv3d(long in_channels, long out_channels, long kernel_size, Padding padding, long stride = 1L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Conv3d(in_channels, out_channels, (kernel_size, kernel_size, kernel_size), (stride, stride, stride), null, padding, (dilation, dilation, dilation), groups, bias, padding_mode, device, dtype);
			}

			public static Conv3d Conv3d(long in_channels, long out_channels, (long, long, long) kernel_size, Padding padding, (long, long, long)? stride = null, (long, long, long)? dilation = null, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				(long, long, long) valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L, 1L);
					dilation = valueOrDefault;
				}
				return new Conv3d(in_channels, out_channels, kernel_size, stride.Value, null, padding, dilation.Value, groups, bias, padding_mode, device, dtype);
			}

			public static ConvTranspose1d ConvTranspose1d(long in_channels, long out_channels, long kernel_size, long stride = 1L, long padding = 0L, long output_padding = 0L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new ConvTranspose1d(in_channels, out_channels, kernel_size, stride, padding, dilation, output_padding, groups, bias, padding_mode, device, dtype);
			}

			public static ConvTranspose2d ConvTranspose2d(long in_channels, long out_channels, long kernel_size, long stride = 1L, long padding = 0L, long output_padding = 0L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new ConvTranspose2d(in_channels, out_channels, (kernel_size, kernel_size), (stride, stride), (padding, padding), (dilation, dilation), (output_padding, output_padding), groups, bias, padding_mode, device, dtype);
			}

			public static ConvTranspose2d ConvTranspose2d(long in_channels, long out_channels, (long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null, (long, long)? output_padding = null, (long, long)? dilation = null, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				(long, long) valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = padding.GetValueOrDefault();
				if (!padding.HasValue)
				{
					valueOrDefault = (0L, 0L);
					padding = valueOrDefault;
				}
				valueOrDefault = output_padding.GetValueOrDefault();
				if (!output_padding.HasValue)
				{
					valueOrDefault = (0L, 0L);
					output_padding = valueOrDefault;
				}
				valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L);
					dilation = valueOrDefault;
				}
				return new ConvTranspose2d(in_channels, out_channels, kernel_size, stride.Value, padding.Value, dilation.Value, output_padding.Value, groups, bias, padding_mode, device, dtype);
			}

			public static ConvTranspose3d ConvTranspose3d(long in_channels, long out_channels, long kernel_size, long stride = 1L, long padding = 0L, long output_padding = 0L, long dilation = 1L, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new ConvTranspose3d(in_channels, out_channels, (kernel_size, kernel_size, kernel_size), (stride, stride, stride), (padding, padding, padding), (dilation, dilation, dilation), (output_padding, output_padding, output_padding), groups, bias, padding_mode, device, dtype);
			}

			public static ConvTranspose3d ConvTranspose3d(long in_channels, long out_channels, (long, long, long) kernel_size, (long, long, long)? stride = null, (long, long, long)? padding = null, (long, long, long)? output_padding = null, (long, long, long)? dilation = null, PaddingModes padding_mode = PaddingModes.Zeros, long groups = 1L, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				(long, long, long) valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = padding.GetValueOrDefault();
				if (!padding.HasValue)
				{
					valueOrDefault = (0L, 0L, 0L);
					padding = valueOrDefault;
				}
				valueOrDefault = output_padding.GetValueOrDefault();
				if (!output_padding.HasValue)
				{
					valueOrDefault = (0L, 0L, 0L);
					output_padding = valueOrDefault;
				}
				valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L, 1L);
					dilation = valueOrDefault;
				}
				return new ConvTranspose3d(in_channels, out_channels, kernel_size, stride.Value, padding.Value, dilation.Value, output_padding.Value, groups, bias, padding_mode, device, dtype);
			}

			public static CosineSimilarity CosineSimilarity(long dim = 1L, double eps = 1E-08)
			{
				return new CosineSimilarity(dim, eps);
			}

			public static Dropout Dropout(double p = 0.5, bool inplace = false)
			{
				return new Dropout(p, inplace);
			}

			public static Dropout1d Dropout1d(double p = 0.5, bool inplace = false)
			{
				return new Dropout1d(p, inplace);
			}

			public static Dropout2d Dropout2d(double p = 0.5, bool inplace = false)
			{
				return new Dropout2d(p, inplace);
			}

			public static Dropout3d Dropout3d(double p = 0.5, bool inplace = false)
			{
				return new Dropout3d(p, inplace);
			}

			public static Embedding Embedding(long num_embeddings, long embedding_dims, long? padding_idx = null, double? max_norm = null, double norm_type = 2.0, bool scale_grad_by_freq = false, bool sparse = false, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_Embedding_ctor(num_embeddings, embedding_dims, padding_idx.HasValue ? padding_idx.Value : (-1), padding_idx.HasValue, max_norm.HasValue ? max_norm.Value : 0.0, max_norm.HasValue, norm_type, scale_grad_by_freq, sparse, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Embedding(intPtr, pBoxedModule).MoveModule<Embedding>(device, dtype);
			}

			public static Embedding Embedding_from_pretrained(Tensor embeddings, bool freeze = true, long? padding_idx = null, double? max_norm = null, double norm_type = 2.0, bool scale_grad_by_freq = false, bool sparse = false, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_Embedding_from_pretrained(embeddings.Handle, freeze, padding_idx.HasValue ? padding_idx.Value : (-1), padding_idx.HasValue, max_norm.HasValue ? max_norm.Value : 0.0, max_norm.HasValue, norm_type, scale_grad_by_freq, sparse, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Embedding(intPtr, pBoxedModule).MoveModule<Embedding>(device, dtype);
			}

			public static EmbeddingBag EmbeddingBag(long num_embeddings, long embedding_dims, double? max_norm = null, double norm_type = 2.0, bool scale_grad_by_freq = false, EmbeddingBagMode mode = EmbeddingBagMode.Mean, bool sparse = false, bool include_last_offset = false, long padding_index = -1L, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_EmbeddingBag_ctor(num_embeddings, embedding_dims, max_norm.HasValue ? max_norm.Value : 0.0, max_norm.HasValue, norm_type, scale_grad_by_freq, (long)mode, sparse, include_last_offset, padding_index, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new EmbeddingBag(intPtr, pBoxedModule).MoveModule<EmbeddingBag>(device, dtype);
			}

			public static EmbeddingBag EmbeddingBag_from_pretrained(Tensor embeddings, bool freeze = true, double? max_norm = null, double norm_type = 2.0, bool scale_grad_by_freq = false, EmbeddingBagMode mode = EmbeddingBagMode.Mean, bool sparse = false, bool include_last_offset = false, long padding_index = -1L, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_EmbeddingBag_from_pretrained(embeddings.Handle, freeze, max_norm.HasValue ? max_norm.Value : 0.0, max_norm.HasValue, norm_type, scale_grad_by_freq, (long)mode, sparse, include_last_offset, padding_index, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new EmbeddingBag(intPtr, pBoxedModule).MoveModule<EmbeddingBag>(device, dtype);
			}

			public static FeatureAlphaDropout FeatureAlphaDropout(double p, bool inplace)
			{
				return new FeatureAlphaDropout(p, inplace);
			}

			public static FeatureAlphaDropout FeatureAlphaDropout(double p = 0.5)
			{
				return new FeatureAlphaDropout(p);
			}

			public static Flatten Flatten(long start_dim = 1L, long end_dim = -1L)
			{
				return new Flatten(start_dim, end_dim);
			}

			public static Fold Fold(long output_size, long kernel_size, long dilation = 1L, long padding = 0L, long stride = 1L)
			{
				return new Fold((output_size, output_size), (kernel_size, kernel_size), (dilation, dilation), (padding, padding), (stride, stride));
			}

			public static Fold Fold((long, long) output_size, (long, long) kernel_size, (long, long)? dilation = null, (long, long)? padding = null, (long, long)? stride = null)
			{
				(long, long) valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L);
					dilation = valueOrDefault;
				}
				valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = padding.GetValueOrDefault();
				if (!padding.HasValue)
				{
					valueOrDefault = (0L, 0L);
					padding = valueOrDefault;
				}
				return new Fold(output_size, kernel_size, dilation.Value, padding.Value, stride.Value);
			}

			public static Identity Identity()
			{
				return new Identity();
			}

			public static Linear Linear(long inputSize, long outputSize, bool hasBias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new Linear(inputSize, outputSize, hasBias, device, dtype);
			}

			public static Linear Linear(Parameter weight, Parameter? bias = null)
			{
				return new Linear(weight, bias);
			}

			public static CrossEntropyLoss CrossEntropyLoss(Tensor? weight = null, long? ignore_index = null, Reduction reduction = Reduction.Mean)
			{
				return new CrossEntropyLoss(weight, ignore_index, reduction);
			}

			public static BCELoss BCELoss(Tensor? weight = null, Reduction reduction = Reduction.Mean)
			{
				return new BCELoss(weight, reduction);
			}

			public static BCEWithLogitsLoss BCEWithLogitsLoss(Tensor? weight = null, Reduction reduction = Reduction.Mean, Tensor? pos_weights = null)
			{
				return new BCEWithLogitsLoss(weight, reduction, pos_weights);
			}

			public static CosineEmbeddingLoss CosineEmbeddingLoss(double margin = 0.0, Reduction reduction = Reduction.Mean)
			{
				return new CosineEmbeddingLoss(margin, reduction);
			}

			public static CTCLoss CTCLoss(long blank = 0L, bool zero_infinity = false, Reduction reduction = Reduction.Mean)
			{
				return new CTCLoss(blank, zero_infinity, reduction);
			}

			public static HingeEmbeddingLoss HingeEmbeddingLoss(double margin = 1.0, Reduction reduction = Reduction.Mean)
			{
				return new HingeEmbeddingLoss(margin, reduction);
			}

			public static HuberLoss HuberLoss(double delta = 1.0, Reduction reduction = Reduction.Mean)
			{
				return new HuberLoss(delta, reduction);
			}

			public static MarginRankingLoss MarginRankingLoss(double margin = 0.0, Reduction reduction = Reduction.Mean)
			{
				return new MarginRankingLoss(margin, reduction);
			}

			public static MultiLabelSoftMarginLoss MultiLabelSoftMarginLoss(Tensor? weight = null, Reduction reduction = Reduction.Mean)
			{
				return new MultiLabelSoftMarginLoss(weight, reduction);
			}

			public static MultiMarginLoss MultiMarginLoss(int p = 1, double margin = 1.0, Tensor? weight = null, Reduction reduction = Reduction.Mean)
			{
				return new MultiMarginLoss(p, margin, weight, reduction);
			}

			public static MSELoss MSELoss(Reduction reduction = Reduction.Mean)
			{
				return new MSELoss(reduction);
			}

			public static L1Loss L1Loss(Reduction reduction = Reduction.Mean)
			{
				return new L1Loss(reduction);
			}

			public static NLLLoss NLLLoss(Tensor? weight = null, Reduction reduction = Reduction.Mean)
			{
				return new NLLLoss(weight, reduction);
			}

			public static PoissonNLLLoss PoissonNLLLoss(bool log_input = true, bool full = false, float eps = 1E-08f, Reduction reduction = Reduction.Mean)
			{
				return new PoissonNLLLoss(log_input, full, eps, reduction);
			}

			public static KLDivLoss KLDivLoss(bool log_target = true, Reduction reduction = Reduction.Mean)
			{
				return new KLDivLoss(log_target, reduction);
			}

			public static SoftMarginLoss SoftMarginLoss(Reduction reduction = Reduction.Mean)
			{
				return new SoftMarginLoss(reduction);
			}

			public static TripletMarginLoss TripletMarginLoss(double margin = 1.0, long p = 2L, double eps = 1E-06, bool swap = false, Reduction reduction = Reduction.Mean)
			{
				return new TripletMarginLoss(margin, p, eps, swap, reduction);
			}

			public static TripletMarginWithDistanceLoss TripletMarginWithDistanceLoss(Func<Tensor, Tensor, Tensor>? distance = null, double margin = 1.0, bool swap = false, Reduction reduction = Reduction.Mean)
			{
				return new TripletMarginWithDistanceLoss(distance, margin, swap, reduction);
			}

			public static GaussianNLLLoss GaussianNLLLoss(bool full = false, float eps = 1E-08f, Reduction reduction = Reduction.Mean)
			{
				return new GaussianNLLLoss(full, eps, reduction);
			}

			public static MultiLabelMarginLoss MultiLabelMarginLoss(Reduction reduction = Reduction.Mean)
			{
				return new MultiLabelMarginLoss(reduction);
			}

			public static SmoothL1Loss SmoothL1Loss(Reduction reduction = Reduction.Mean, double beta = 1.0)
			{
				return new SmoothL1Loss(reduction, beta);
			}

			public static ModuleDict<Module> ModuleDict(params (string, Module)[] modules)
			{
				ModuleDict<Module> moduleDict = new ModuleDict<Module>();
				for (int i = 0; i < modules.Length; i++)
				{
					var (item, item2) = modules[i];
					moduleDict.Add((item, item2));
				}
				return moduleDict;
			}

			public static ModuleDict<T> ModuleDict<T>(params (string, T)[] modules) where T : Module
			{
				ModuleDict<T> moduleDict = new ModuleDict<T>();
				for (int i = 0; i < modules.Length; i++)
				{
					var (item, item2) = modules[i];
					moduleDict.Add((item, item2));
				}
				return moduleDict;
			}

			public static ModuleList<Module> ModuleList(params Module[] modules)
			{
				return new ModuleList<Module>(modules);
			}

			public static ModuleList<T> ModuleList<T>(params T[] modules) where T : Module
			{
				return new ModuleList<T>(modules);
			}

			public static MultiheadAttention MultiheadAttention(long embedded_dim, long num_heads, double dropout = 0.0, bool bias = true, bool add_bias_kv = false, bool add_zero_attn = false, long? kdim = null, long? vdim = null)
			{
				long kdim2 = (kdim.HasValue ? kdim.Value : embedded_dim);
				long vdim2 = (vdim.HasValue ? vdim.Value : embedded_dim);
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_MultiheadAttention_ctor(embedded_dim, num_heads, dropout, bias, add_bias_kv, add_zero_attn, kdim2, vdim2, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new MultiheadAttention(intPtr, pBoxedModule);
			}

			public static BatchNorm1d BatchNorm1d(long num_features, double eps = 1E-05, double momentum = 0.1, bool affine = true, bool track_running_stats = true, Device? device = null, ScalarType? dtype = null)
			{
				return new BatchNorm1d(num_features, eps, momentum, affine, track_running_stats, device, dtype);
			}

			public static BatchNorm2d BatchNorm2d(long num_features, double eps = 1E-05, double momentum = 0.1, bool affine = true, bool track_running_stats = true, Device? device = null, ScalarType? dtype = null)
			{
				return new BatchNorm2d(num_features, eps, momentum, affine, track_running_stats, device, dtype);
			}

			public static BatchNorm3d BatchNorm3d(long num_features, double eps = 1E-05, double momentum = 0.1, bool affine = true, bool track_running_stats = true, Device? device = null, ScalarType? dtype = null)
			{
				return new BatchNorm3d(num_features, eps, momentum, affine, track_running_stats, device, dtype);
			}

			public static GroupNorm GroupNorm(long num_groups, long num_channels, double eps = 1E-05, bool affine = true, Device? device = null, ScalarType? dtype = null)
			{
				return new GroupNorm(num_groups, num_channels, eps, affine, device, dtype);
			}

			public static InstanceNorm1d InstanceNorm1d(long num_features, double eps = 1E-05, double momentum = 0.1, bool affine = false, bool track_running_stats = false, Device? device = null, ScalarType? dtype = null)
			{
				return new InstanceNorm1d(num_features, eps, momentum, affine, track_running_stats, device, dtype);
			}

			public static InstanceNorm2d InstanceNorm2d(long num_features, double eps = 1E-05, double momentum = 0.1, bool affine = false, bool track_running_stats = false, Device? device = null, ScalarType? dtype = null)
			{
				return new InstanceNorm2d(num_features, eps, momentum, affine, track_running_stats, device, dtype);
			}

			public static InstanceNorm3d InstanceNorm3d(long num_features, double eps = 1E-05, double momentum = 0.1, bool affine = false, bool track_running_stats = false, Device? device = null, ScalarType? dtype = null)
			{
				return new InstanceNorm3d(num_features, eps, momentum, affine, track_running_stats, device, dtype);
			}

			public static LayerNorm LayerNorm(long[] normalized_shape, double eps = 1E-05, bool elementwise_affine = true, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return new LayerNorm(normalized_shape, eps, elementwise_affine, bias, device, dtype);
			}

			public static LayerNorm LayerNorm(long normalized_shape, double eps = 1E-05, bool elementwise_affine = true, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				return LayerNorm(new long[1] { normalized_shape }, eps, elementwise_affine, bias, device, dtype);
			}

			public static LocalResponseNorm LocalResponseNorm(long size, double alpha = 0.0001, double beta = 0.75, double k = 1.0)
			{
				return new LocalResponseNorm(size, alpha, beta, k);
			}

			public static ConstantPad1d ConstantPad1d(long padding, double value)
			{
				return new ConstantPad1d(value, padding, padding);
			}

			public static ConstantPad1d ConstantPad1d((long, long) padding, double value)
			{
				return new ConstantPad1d(value, padding.Item1, padding.Item2);
			}

			public static ConstantPad2d ConstantPad2d(long padding, double value)
			{
				return new ConstantPad2d(value, padding, padding, padding, padding);
			}

			public static ConstantPad2d ConstantPad2d((long, long, long, long) padding, double value)
			{
				return new ConstantPad2d(value, padding.Item1, padding.Item2, padding.Item3, padding.Item4);
			}

			public static ConstantPad3d ConstantPad3d(long padding, double value)
			{
				return new ConstantPad3d(value, padding, padding, padding, padding, padding, padding);
			}

			public static ConstantPad3d ConstantPad3d((long, long, long, long, long, long) padding, double value)
			{
				return new ConstantPad3d(value, padding.Item1, padding.Item2, padding.Item3, padding.Item4, padding.Item5, padding.Item6);
			}

			public static ReflectionPad1d ReflectionPad1d(long padding)
			{
				return new ReflectionPad1d(padding, padding);
			}

			public static ReflectionPad1d ReflectionPad1d((long, long) padding)
			{
				return new ReflectionPad1d(padding.Item1, padding.Item2);
			}

			public static ReflectionPad2d ReflectionPad2d(long padding)
			{
				return new ReflectionPad2d(padding, padding, padding, padding);
			}

			public static ReflectionPad2d ReflectionPad2d((long, long, long, long) padding)
			{
				return new ReflectionPad2d(padding.Item1, padding.Item2, padding.Item3, padding.Item4);
			}

			public static ReflectionPad3d ReflectionPad3d(long padding)
			{
				return new ReflectionPad3d(padding, padding, padding, padding, padding, padding);
			}

			public static ReflectionPad3d ReflectionPad3d((long, long, long, long, long, long) padding)
			{
				return new ReflectionPad3d(padding.Item1, padding.Item2, padding.Item3, padding.Item4, padding.Item5, padding.Item6);
			}

			public static ReplicationPad1d ReplicationPad1d(long padding)
			{
				return new ReplicationPad1d(padding, padding);
			}

			public static ReplicationPad1d ReplicationPad1d((long, long) padding)
			{
				return new ReplicationPad1d(padding.Item1, padding.Item2);
			}

			public static ReplicationPad2d ReplicationPad2d(long padding)
			{
				return new ReplicationPad2d(padding, padding, padding, padding);
			}

			public static ReplicationPad2d ReplicationPad2d((long, long, long, long) padding)
			{
				return new ReplicationPad2d(padding.Item1, padding.Item2, padding.Item3, padding.Item4);
			}

			public static ReplicationPad3d ReplicationPad3d(long padding)
			{
				return new ReplicationPad3d(padding, padding, padding, padding, padding, padding);
			}

			public static ReplicationPad3d ReplicationPad3d((long, long, long, long, long, long) padding)
			{
				return new ReplicationPad3d(padding.Item1, padding.Item2, padding.Item3, padding.Item4, padding.Item5, padding.Item6);
			}

			public static ZeroPad2d ZeroPad2d(long padding)
			{
				return new ZeroPad2d(padding, padding, padding, padding);
			}

			public static ZeroPad2d ZeroPad2d((long, long, long, long) padding)
			{
				return new ZeroPad2d(padding.Item1, padding.Item2, padding.Item3, padding.Item4);
			}

			public static PairwiseDistance PairwiseDistance(double p = 2.0, double eps = 1E-06, bool keepdim = false)
			{
				return new PairwiseDistance(p, eps, keepdim);
			}

			public static Parameter Parameter(Tensor data, bool requires_grad = true)
			{
				return new Parameter(data, requires_grad);
			}

			public static ParameterDict ParameterDict(params (string, Parameter)[] parameters)
			{
				ParameterDict parameterDict = new ParameterDict();
				for (int i = 0; i < parameters.Length; i++)
				{
					var (key, value) = parameters[i];
					parameterDict.Add(key, value);
				}
				return parameterDict;
			}

			public static ParameterList ParameterList(params Parameter[] parameters)
			{
				return new ParameterList(parameters);
			}

			public static PixelShuffle PixelShuffle(long upscale_factor)
			{
				return new PixelShuffle(upscale_factor);
			}

			public static PixelUnshuffle PixelUnshuffle(long downscale_factor)
			{
				return new PixelUnshuffle(downscale_factor);
			}

			public static AdaptiveAvgPool1d AdaptiveAvgPool1d(long output_size)
			{
				return new AdaptiveAvgPool1d(output_size);
			}

			public static AdaptiveAvgPool2d AdaptiveAvgPool2d(long[] output_size)
			{
				return new AdaptiveAvgPool2d(output_size);
			}

			public static AdaptiveAvgPool2d AdaptiveAvgPool2d((long, long) output_size)
			{
				return new AdaptiveAvgPool2d(new long[2] { output_size.Item1, output_size.Item2 });
			}

			public static AdaptiveAvgPool2d AdaptiveAvgPool2d(long output_size)
			{
				return new AdaptiveAvgPool2d(new long[2] { output_size, output_size });
			}

			public static AdaptiveAvgPool3d AdaptiveAvgPool3d(long[] output_size)
			{
				return new AdaptiveAvgPool3d(output_size);
			}

			public static AdaptiveAvgPool3d AdaptiveAvgPool3d((long, long, long) output_size)
			{
				return new AdaptiveAvgPool3d(new long[3] { output_size.Item1, output_size.Item2, output_size.Item3 });
			}

			public static AdaptiveAvgPool3d AdaptiveAvgPool3d(long output_size)
			{
				return new AdaptiveAvgPool3d(new long[3] { output_size, output_size, output_size });
			}

			public static AdaptiveMaxPool1d AdaptiveMaxPool1d(long output_size)
			{
				return new AdaptiveMaxPool1d(output_size);
			}

			public static AdaptiveMaxPool2d AdaptiveMaxPool2d(long[] output_size)
			{
				return new AdaptiveMaxPool2d(output_size);
			}

			public static AdaptiveMaxPool3d AdaptiveMaxPool3d(long[] output_size)
			{
				return new AdaptiveMaxPool3d(output_size);
			}

			public static AvgPool1d AvgPool1d(long kernel_size, long? stride = null, long padding = 0L, bool ceil_mode = false, bool count_include_pad = true)
			{
				return new AvgPool1d(kernel_size, stride, padding, ceil_mode, count_include_pad);
			}

			public static AvgPool2d AvgPool2d(long[] kernel_size, long[] stride = null, long[] padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			{
				return new AvgPool2d(kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
			}

			public static AvgPool2d AvgPool2d((long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			{
				long[] kernel_size2 = new long[2] { kernel_size.Item1, kernel_size.Item2 };
				long[] stride2 = ((!stride.HasValue) ? null : new long[2]
				{
					stride.Value.Item1,
					stride.Value.Item2
				});
				long[] padding2 = ((!padding.HasValue) ? null : new long[2]
				{
					padding.Value.Item1,
					padding.Value.Item2
				});
				return new AvgPool2d(kernel_size2, stride2, padding2, ceil_mode, count_include_pad, divisor_override);
			}

			public static AvgPool2d AvgPool2d(long kernel_size, long? stride = null, long? padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			{
				long[] kernel_size2 = new long[2] { kernel_size, kernel_size };
				long[] stride2 = ((!stride.HasValue) ? null : new long[2] { stride.Value, stride.Value });
				long[] padding2 = ((!padding.HasValue) ? null : new long[2] { padding.Value, padding.Value });
				return new AvgPool2d(kernel_size2, stride2, padding2, ceil_mode, count_include_pad, divisor_override);
			}

			public static AvgPool3d AvgPool3d(long[] kernel_size, long[] stride = null, long[] padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			{
				return new AvgPool3d(kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
			}

			public static AvgPool3d AvgPool3d((long, long, long) kernel_size, (long, long, long)? stride = null, (long, long, long)? padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			{
				long[] kernel_size2 = new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 };
				long[] stride2 = ((!stride.HasValue) ? null : new long[3]
				{
					stride.Value.Item1,
					stride.Value.Item2,
					stride.Value.Item3
				});
				long[] padding2 = ((!padding.HasValue) ? null : new long[3]
				{
					padding.Value.Item1,
					padding.Value.Item2,
					padding.Value.Item3
				});
				return new AvgPool3d(kernel_size2, stride2, padding2, ceil_mode, count_include_pad, divisor_override);
			}

			public static AvgPool3d AvgPool3d(long kernel_size, long? stride = null, long? padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			{
				long[] kernel_size2 = new long[3] { kernel_size, kernel_size, kernel_size };
				long[] stride2 = ((!stride.HasValue) ? null : new long[3] { stride.Value, stride.Value, stride.Value });
				long[] padding2 = ((!padding.HasValue) ? null : new long[3] { padding.Value, padding.Value, padding.Value });
				return new AvgPool3d(kernel_size2, stride2, padding2, ceil_mode, count_include_pad, divisor_override);
			}

			public static FractionalMaxPool2d FractionalMaxPool2d(long kernel_size, long? output_size = null, double? output_ratio = null)
			{
				long[] output_size2 = ((!output_size.HasValue) ? null : new long[2] { output_size.Value, output_size.Value });
				double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[2] { output_ratio.Value, output_ratio.Value });
				return FractionalMaxPool2d(new long[2] { kernel_size, kernel_size }, output_size2, output_ratio2);
			}

			public static FractionalMaxPool2d FractionalMaxPool2d((long, long) kernel_size, (long, long)? output_size = null, (double, double)? output_ratio = null)
			{
				long[] output_size2 = ((!output_size.HasValue) ? null : new long[2]
				{
					output_size.Value.Item1,
					output_size.Value.Item2
				});
				double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[2]
				{
					output_ratio.Value.Item1,
					output_ratio.Value.Item2
				});
				return FractionalMaxPool2d(new long[2] { kernel_size.Item1, kernel_size.Item2 }, output_size2, output_ratio2);
			}

			public static FractionalMaxPool2d FractionalMaxPool2d(long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
			{
				if (kernel_size == null || kernel_size.Length != 2)
				{
					throw new ArgumentException("Kernel size must contain two elements.");
				}
				if (output_size != null && output_size.Length != 2)
				{
					throw new ArgumentException("output_size must contain two elements.");
				}
				if (output_ratio != null && output_ratio.Length != 2)
				{
					throw new ArgumentException("output_ratio must contain two elements.");
				}
				if (output_size == null && output_ratio == null)
				{
					throw new ArgumentNullException("Only one of output_size and output_ratio may be specified.");
				}
				if (output_size != null && output_ratio != null)
				{
					throw new ArgumentNullException("FractionalMaxPool2d requires specifying either an output size, or a pooling ratio.");
				}
				return new FractionalMaxPool2d(kernel_size, output_size, output_ratio);
			}

			public static FractionalMaxPool3d FractionalMaxPool3d(long kernel_size, long? output_size = null, double? output_ratio = null)
			{
				long[] output_size2 = ((!output_size.HasValue) ? null : new long[3] { output_size.Value, output_size.Value, output_size.Value });
				double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[3] { output_ratio.Value, output_ratio.Value, output_ratio.Value });
				return FractionalMaxPool3d(new long[3] { kernel_size, kernel_size, kernel_size }, output_size2, output_ratio2);
			}

			public static FractionalMaxPool3d FractionalMaxPool3d((long, long, long) kernel_size, (long, long, long)? output_size = null, (double, double, double)? output_ratio = null)
			{
				long[] output_size2 = ((!output_size.HasValue) ? null : new long[3]
				{
					output_size.Value.Item1,
					output_size.Value.Item2,
					output_size.Value.Item3
				});
				double[] output_ratio2 = ((!output_ratio.HasValue) ? null : new double[3]
				{
					output_ratio.Value.Item1,
					output_ratio.Value.Item2,
					output_ratio.Value.Item3
				});
				return FractionalMaxPool3d(new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, output_size2, output_ratio2);
			}

			public static FractionalMaxPool3d FractionalMaxPool3d(long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
			{
				if (kernel_size == null || kernel_size.Length != 3)
				{
					throw new ArgumentException("Kernel size must contain three elements.");
				}
				if (output_size != null && output_size.Length != 3)
				{
					throw new ArgumentException("output_size must contain three elements.");
				}
				if (output_ratio != null && output_ratio.Length != 3)
				{
					throw new ArgumentException("output_ratio must contain three elements.");
				}
				if (output_size == null && output_ratio == null)
				{
					throw new ArgumentNullException("Only one of output_size and output_ratio may be specified.");
				}
				if (output_size != null && output_ratio != null)
				{
					throw new ArgumentNullException("FractionalMaxPool3d requires specifying either an output size, or a pooling ratio.");
				}
				return new FractionalMaxPool3d(kernel_size, output_size, output_ratio);
			}

			public static LPPool1d LPPool1d(double norm_type, long kernel_size, long? stride = null, bool ceil_mode = false)
			{
				return new LPPool1d(norm_type, kernel_size, stride, ceil_mode);
			}

			public static LPPool2d LPPool2d(double norm_type, long[] kernel_size, long[] stride = null, bool ceil_mode = false)
			{
				return new LPPool2d(norm_type, kernel_size, stride, ceil_mode);
			}

			public static LPPool2d LPPool2d(double norm_type, long kernel_size, long? stride = null, bool ceil_mode = false)
			{
				return new LPPool2d(norm_type, new long[2] { kernel_size, kernel_size }, (!stride.HasValue) ? null : new long[2] { stride.Value, stride.Value }, ceil_mode);
			}

			public static MaxPool1d MaxPool1d(long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
			{
				return new MaxPool1d(kernel_size, stride, padding, dilation, ceil_mode);
			}

			public static MaxPool2d MaxPool2d(long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
			{
				long[] array = new long[2] { kernel_size, kernel_size };
				long[] stride2 = ((!stride.HasValue) ? array.ToArray() : new long[2] { stride.Value, stride.Value });
				long[] padding2 = ((!padding.HasValue) ? new long[2] : new long[2] { padding.Value, padding.Value });
				long[] dilation2 = ((!dilation.HasValue) ? new long[2] { 1L, 1L } : new long[2] { dilation.Value, dilation.Value });
				return new MaxPool2d(array, stride2, padding2, dilation2, ceil_mode);
			}

			public static MaxPool2d MaxPool2d((long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null, (long, long)? dilation = null, bool ceil_mode = false)
			{
				long[] array = new long[2] { kernel_size.Item1, kernel_size.Item2 };
				long[] stride2 = ((!stride.HasValue) ? array.ToArray() : new long[2]
				{
					stride.Value.Item1,
					stride.Value.Item2
				});
				long[] padding2 = ((!padding.HasValue) ? new long[2] : new long[2]
				{
					padding.Value.Item1,
					padding.Value.Item2
				});
				long[] dilation2 = ((!dilation.HasValue) ? new long[2] { 1L, 1L } : new long[2]
				{
					dilation.Value.Item1,
					dilation.Value.Item2
				});
				return new MaxPool2d(array, stride2, padding2, dilation2, ceil_mode);
			}

			public static MaxPool2d MaxPool2d(long[] kernel_size, long[] stride = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
			{
				return new MaxPool2d(kernel_size, stride, padding, dilation, ceil_mode);
			}

			public static MaxPool3d MaxPool3d(long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
			{
				long[] stride2 = ((!stride.HasValue) ? null : new long[3] { stride.Value, stride.Value, stride.Value });
				long[] padding2 = ((!padding.HasValue) ? null : new long[3] { padding.Value, padding.Value, padding.Value });
				long[] dilation2 = ((!dilation.HasValue) ? null : new long[3] { dilation.Value, dilation.Value, dilation.Value });
				return MaxPool3d(new long[3] { kernel_size, kernel_size, kernel_size }, stride2, padding2, dilation2, ceil_mode);
			}

			public static MaxPool3d MaxPool3d((long, long, long) kernel_size, (long, long, long)? stride = null, (long, long, long)? padding = null, (long, long, long)? dilation = null, bool ceil_mode = false)
			{
				long[] stride2 = ((!stride.HasValue) ? null : new long[3]
				{
					stride.Value.Item1,
					stride.Value.Item2,
					stride.Value.Item3
				});
				long[] padding2 = ((!padding.HasValue) ? null : new long[3]
				{
					padding.Value.Item1,
					padding.Value.Item2,
					padding.Value.Item3
				});
				long[] dilation2 = ((!dilation.HasValue) ? null : new long[3]
				{
					dilation.Value.Item1,
					dilation.Value.Item2,
					dilation.Value.Item3
				});
				return MaxPool3d(new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, stride2, padding2, dilation2, ceil_mode);
			}

			public static MaxPool3d MaxPool3d(long[] kernel_size, long[] stride = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
			{
				return new MaxPool3d(kernel_size, stride, padding, dilation, ceil_mode);
			}

			public static MaxUnpool1d MaxUnpool1d(long kernel_size, long? stride = null, long? padding = null)
			{
				return new MaxUnpool1d(kernel_size, stride, padding);
			}

			public static MaxUnpool2d MaxUnpool2d(long kernel_size, long? stride = null, long? padding = null)
			{
				long[] stride2 = ((!stride.HasValue) ? null : new long[2] { stride.Value, stride.Value });
				long[] padding2 = ((!padding.HasValue) ? null : new long[2] { padding.Value, padding.Value });
				return new MaxUnpool2d(new long[2] { kernel_size, kernel_size }, stride2, padding2);
			}

			public static MaxUnpool2d MaxUnpool2d((long, long) kernel_size, (long, long)? stride = null, (long, long)? padding = null)
			{
				long[] stride2 = ((!stride.HasValue) ? null : new long[2]
				{
					stride.Value.Item1,
					stride.Value.Item2
				});
				long[] padding2 = ((!padding.HasValue) ? null : new long[2]
				{
					padding.Value.Item1,
					padding.Value.Item2
				});
				return new MaxUnpool2d(new long[2] { kernel_size.Item1, kernel_size.Item2 }, stride2, padding2);
			}

			public static MaxUnpool2d MaxUnpool2d(long[] kernel_size, long[] stride = null, long[] padding = null)
			{
				return new MaxUnpool2d(kernel_size, stride, padding);
			}

			public static MaxUnpool3d MaxUnpool3d(long kernel_size, long? stride = null, long? padding = null)
			{
				long[] stride2 = ((!stride.HasValue) ? null : new long[3] { stride.Value, stride.Value, stride.Value });
				long[] padding2 = ((!padding.HasValue) ? null : new long[3] { padding.Value, padding.Value, padding.Value });
				return new MaxUnpool3d(new long[3] { kernel_size, kernel_size, kernel_size }, stride2, padding2);
			}

			public static MaxUnpool3d MaxUnpool3d((long, long, long) kernel_size, (long, long, long)? stride = null, (long, long, long)? padding = null)
			{
				long[] stride2 = ((!stride.HasValue) ? null : new long[3]
				{
					stride.Value.Item1,
					stride.Value.Item2,
					stride.Value.Item3
				});
				long[] padding2 = ((!padding.HasValue) ? null : new long[3]
				{
					padding.Value.Item1,
					padding.Value.Item2,
					padding.Value.Item3
				});
				return new MaxUnpool3d(new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, stride2, padding2);
			}

			public static MaxUnpool3d MaxUnpool3d(long[] kernel_size, long[] stride = null, long[] padding = null)
			{
				return new MaxUnpool3d(kernel_size, stride, padding);
			}

			public static GRU GRU(long inputSize, long hiddenSize, long numLayers = 1L, bool bias = true, bool batchFirst = false, double dropout = 0.0, bool bidirectional = false, Device device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_GRU_ctor(inputSize, hiddenSize, numLayers, bias, batchFirst, dropout, bidirectional, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new GRU(intPtr, pBoxedModule, hiddenSize, numLayers, batchFirst, bidirectional).MoveModule<GRU>(device, dtype);
			}

			public static GRUCell GRUCell(long inputSize, long hiddenSize, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_GRUCell_ctor(inputSize, hiddenSize, bias, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new GRUCell(intPtr, pBoxedModule).MoveModule<GRUCell>(device, dtype);
			}

			public static LSTM LSTM(long inputSize, long hiddenSize, long numLayers = 1L, bool bias = true, bool batchFirst = false, double dropout = 0.0, bool bidirectional = false, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_LSTM_ctor(inputSize, hiddenSize, numLayers, bias, batchFirst, dropout, bidirectional, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new LSTM(intPtr, pBoxedModule, hiddenSize, numLayers, batchFirst, bidirectional).MoveModule<LSTM>(device, dtype);
			}

			public static LSTMCell LSTMCell(long inputSize, long hiddenSize, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_LSTMCell_ctor(inputSize, hiddenSize, bias, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new LSTMCell(intPtr, pBoxedModule).MoveModule<LSTMCell>(device, dtype);
			}

			public static RNN RNN(long inputSize, long hiddenSize, long numLayers = 1L, NonLinearities nonLinearity = NonLinearities.Tanh, bool bias = true, bool batchFirst = false, double dropout = 0.0, bool bidirectional = false, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_RNN_ctor(inputSize, hiddenSize, numLayers, (long)nonLinearity, bias, batchFirst, dropout, bidirectional, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new RNN(intPtr, pBoxedModule, hiddenSize, numLayers, batchFirst, bidirectional).MoveModule<RNN>(device, dtype);
			}

			public static RNNCell RNNCell(long inputSize, long hiddenSize, NonLinearities nonLinearity = NonLinearities.Tanh, bool bias = true, Device? device = null, ScalarType? dtype = null)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_RNNCell_ctor(inputSize, hiddenSize, (long)nonLinearity, bias, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new RNNCell(intPtr, pBoxedModule).MoveModule<RNNCell>(device, dtype);
			}

			public static Sequential Sequential()
			{
				IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Sequential(intPtr);
			}

			public static Sequential Sequential(params (string name, Module<Tensor, Tensor> submodule)[] modules)
			{
				Sequential sequential = Sequential();
				for (int i = 0; i < modules.Length; i++)
				{
					(string, Module<Tensor, Tensor>) tuple = modules[i];
					sequential.Add(tuple.Item1, tuple.Item2);
				}
				return sequential;
			}

			public static Sequential Sequential(params Module<Tensor, Tensor>[] modules)
			{
				Sequential sequential = Sequential();
				foreach (Module<Tensor, Tensor> module in modules)
				{
					sequential.Add(module);
				}
				return sequential;
			}

			public static Sequential Sequential(params Tuple<string, Module<Tensor, Tensor>>[] modules)
			{
				Sequential sequential = Sequential();
				foreach (Tuple<string, Module<Tensor, Tensor>> tuple in modules)
				{
					sequential.Add(tuple.Item1, tuple.Item2);
				}
				return sequential;
			}

			public static Sequential Sequential(IEnumerable<(string name, Module<Tensor, Tensor> submodule)> modules)
			{
				Sequential sequential = Sequential();
				foreach (var module in modules)
				{
					sequential.Add(module.name, module.submodule);
				}
				return sequential;
			}

			public static Sequential Sequential(IEnumerable<Tuple<string, Module<Tensor, Tensor>>> modules)
			{
				Sequential sequential = Sequential();
				foreach (Tuple<string, Module<Tensor, Tensor>> module in modules)
				{
					sequential.Add(module.Item1, module.Item2);
				}
				return sequential;
			}

			public static Sequential Sequential(IEnumerable<Module<Tensor, Tensor>> modules)
			{
				Sequential sequential = Sequential();
				foreach (Module<Tensor, Tensor> module in modules)
				{
					sequential.Add(module);
				}
				return sequential;
			}

			public static ChannelShuffle ChannelShuffle(long groups)
			{
				return new ChannelShuffle(groups);
			}

			public static Transformer Transformer(long d_model = 512L, long nhead = 8L, long num_encoder_layers = 6L, long num_decoder_layers = 6L, long dim_feedforward = 2048L, double dropout = 0.1, Activations activation = Activations.ReLU)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_Transformer_ctor(d_model, nhead, num_encoder_layers, num_decoder_layers, dim_feedforward, dropout, (long)activation, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Transformer(intPtr, pBoxedModule);
			}

			public static TransformerDecoder TransformerDecoder(TransformerDecoderLayer decoder_layer, long num_layers)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_TransformerDecoder_ctor(decoder_layer.handle, num_layers, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new TransformerDecoder(intPtr, pBoxedModule);
			}

			public static TransformerDecoderLayer TransformerDecoderLayer(long d_model = 512L, long nhead = 8L, long dim_feedforward = 2048L, double dropout = 0.1, Activations activation = Activations.ReLU)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_TransformerDecoderLayer_ctor(d_model, nhead, dim_feedforward, dropout, (long)activation, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new TransformerDecoderLayer(intPtr, pBoxedModule);
			}

			public static TransformerEncoder TransformerEncoder(TransformerEncoderLayer encoder_layer, long num_layers)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_TransformerEncoder_ctor(encoder_layer.handle, num_layers, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new TransformerEncoder(intPtr, pBoxedModule);
			}

			public static TransformerEncoderLayer TransformerEncoderLayer(long d_model = 512L, long nhead = 8L, long dim_feedforward = 2048L, double dropout = 0.1, Activations activation = Activations.ReLU)
			{
				IntPtr pBoxedModule;
				IntPtr intPtr = NativeMethods.THSNN_TransformerEncoderLayer_ctor(d_model, nhead, dim_feedforward, dropout, (long)activation, out pBoxedModule);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new TransformerEncoderLayer(intPtr, pBoxedModule);
			}

			public static Unflatten Unflatten(long dim, long[] unflattened_size)
			{
				return new Unflatten(dim, unflattened_size);
			}

			public static Unfold Unfold(long kernel_size, long dilation = 1L, long padding = 0L, long stride = 1L)
			{
				return new Unfold((kernel_size, kernel_size), (dilation, dilation), (padding, padding), (stride, stride));
			}

			public static Unfold Unfold((long, long) kernel_size, (long, long)? dilation = null, (long, long)? padding = null, (long, long)? stride = null)
			{
				(long, long) valueOrDefault = dilation.GetValueOrDefault();
				if (!dilation.HasValue)
				{
					valueOrDefault = (1L, 1L);
					dilation = valueOrDefault;
				}
				valueOrDefault = stride.GetValueOrDefault();
				if (!stride.HasValue)
				{
					valueOrDefault = (1L, 1L);
					stride = valueOrDefault;
				}
				valueOrDefault = padding.GetValueOrDefault();
				if (!padding.HasValue)
				{
					valueOrDefault = (0L, 0L);
					padding = valueOrDefault;
				}
				return new Unfold(kernel_size, dilation.Value, padding.Value, stride.Value);
			}

			public static Upsample Upsample(long[]? size = null, double[]? scale_factor = null, UpsampleMode mode = UpsampleMode.Nearest, bool? align_corners = null, bool? recompute_scale_factor = null)
			{
				return new Upsample(size, scale_factor, mode, align_corners, recompute_scale_factor);
			}
		}

		public enum UpsampleMode
		{
			Nearest,
			Linear,
			Bilinear,
			Bicubic,
			Trilinear
		}

		public enum InterpolationMode
		{
			Nearest,
			Linear,
			Bilinear,
			Bicubic,
			Trilinear,
			Area,
			NearestExact
		}

		public enum GridSampleMode
		{
			Nearest = 0,
			Bilinear = 2
		}

		public enum GridSamplePaddingMode
		{
			Zeros,
			Reflection,
			Border
		}

		public static class optim
		{
			public static class lr_scheduler
			{
				public abstract class LRScheduler
				{
					internal Optimizer _optimizer;

					internal int _last_epoch = -1;

					internal bool _verbose;

					protected int _step_count;

					internal IList<double> _last_lrs;

					internal IList<double> _base_lrs;

					protected LRScheduler()
					{
					}

					protected LRScheduler(Optimizer optimizer, int last_epoch = -1, bool verbose = false)
					{
						_optimizer = optimizer;
						_last_epoch = last_epoch;
						_verbose = verbose;
						_base_lrs = optimizer.ParamGroups.Select((ILearningRateController pg) => pg.InitialLearningRate).ToList();
						_last_lrs = optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate).ToList();
					}

					public virtual void step()
					{
						step(null);
					}

					public virtual void step(int? epoch)
					{
						_step_count++;
						_last_epoch = (epoch.HasValue ? epoch.Value : (_last_epoch + 1));
						List<double> list = (epoch.HasValue ? get_closed_form_lr() : get_lr()).ToList();
						List<ILearningRateController> list2 = _optimizer.ParamGroups.ToList();
						for (int i = 0; i < _base_lrs.Count; i++)
						{
							list2[i].LearningRate = list[i];
							if (_verbose && _last_lrs[i] != list[i])
							{
								Console.WriteLine($"Adjusting learning rate to {list[i]}");
							}
							_last_lrs[i] = list[i];
						}
					}

					public virtual void step(double current, int? epoch = null)
					{
						step(epoch);
					}

					protected virtual IEnumerable<double> get_lr()
					{
						return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
					}

					protected virtual IEnumerable<double> get_closed_form_lr()
					{
						return get_lr();
					}

					public IEnumerable<double> get_last_lr()
					{
						return _last_lrs;
					}
				}

				public static class impl
				{
					public class LambdaLR : LRScheduler
					{
						private List<Func<int, double>> _lr_lambdas;

						public LambdaLR(Optimizer optimizer, Func<int, double> lr_lambda, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_lr_lambdas = Enumerable.Repeat(lr_lambda, optimizer.ParamGroups.Count()).ToList();
							step();
						}

						public LambdaLR(Optimizer optimizer, IEnumerable<Func<int, double>> lr_lambdas, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_lr_lambdas = lr_lambdas.ToList();
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							List<ILearningRateController> list = _optimizer.ParamGroups.ToList();
							return from i in Enumerable.Range(0, list.Count)
								select _base_lrs[i] * _lr_lambdas[i](_last_epoch);
						}
					}

					public class MultiplicativeLR : LRScheduler
					{
						private List<Func<int, double>> _lr_lambdas;

						public MultiplicativeLR(Optimizer optimizer, IEnumerable<Func<int, double>> lr_lambdas, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_lr_lambdas = lr_lambdas.ToList();
							step();
						}

						public MultiplicativeLR(Optimizer optimizer, Func<int, double> lr_lambda, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_lr_lambdas = Enumerable.Repeat(lr_lambda, optimizer.ParamGroups.Count()).ToList();
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							List<ILearningRateController> pgs = _optimizer.ParamGroups.ToList();
							if (_last_epoch <= 0)
							{
								return from i in Enumerable.Range(0, pgs.Count)
									select pgs[i].LearningRate;
							}
							return from i in Enumerable.Range(0, pgs.Count)
								select pgs[i].LearningRate * _lr_lambdas[i](_last_epoch);
						}
					}

					public class StepLR : LRScheduler
					{
						private int _step_size;

						private double _gamma;

						public StepLR(Optimizer optimizer, int step_size, double gamma = 0.1, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_step_size = step_size;
							_gamma = gamma;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_last_epoch != 0 && _last_epoch % _step_size == 0)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * _gamma);
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							return _base_lrs.Select((double lr) => lr * Math.Pow(_gamma, _last_epoch / _step_size));
						}
					}

					public class MultiStepLR : LRScheduler
					{
						private IList<int> _milestones;

						private IList<int> _sortedMilestones;

						private double _gamma;

						public MultiStepLR(Optimizer optimizer, IList<int> milestones, double gamma = 0.1, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_milestones = milestones;
							_sortedMilestones = (from v in _milestones.Distinct()
								orderby v
								select v).ToList();
							_gamma = gamma;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_milestones.IndexOf(_last_epoch) != -1)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * _gamma);
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							int idx;
							for (idx = _sortedMilestones.Count; idx > 0 && _sortedMilestones[idx - 1] > _last_epoch; idx--)
							{
							}
							return _base_lrs.Select((double lr) => lr * Math.Pow(_gamma, idx));
						}
					}

					public class PolynomialLR : LRScheduler
					{
						private double _total_iters;

						private double _power;

						public PolynomialLR(Optimizer optimizer, int total_iters = 5, double power = 1.0, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_power = power;
							_total_iters = total_iters;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_last_epoch == 0 || (double)_last_epoch > _total_iters)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
							}
							double decay_factor = (1.0 - (double)_last_epoch / _total_iters) / (1.0 - (double)(_last_epoch - 1) / _total_iters);
							if (_power != 1.0)
							{
								decay_factor = Math.Pow(decay_factor, _power);
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * decay_factor);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							return _base_lrs.Select((double lr) => lr * Math.Pow(1.0 - Math.Min(_total_iters, _last_epoch) / _total_iters, _power));
						}
					}

					public class ExponentialLR : LRScheduler
					{
						private double _gamma;

						public ExponentialLR(Optimizer optimizer, double gamma = 0.1, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_gamma = gamma;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_last_epoch != 0)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * _gamma);
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							return _base_lrs.Select((double lr) => lr * Math.Pow(_gamma, _last_epoch));
						}
					}

					public class ConstantLR : LRScheduler
					{
						private double _factor;

						private int _total_iters;

						public ConstantLR(Optimizer optimizer, double factor = 1.0 / 3.0, int total_iters = 5, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_factor = factor;
							_total_iters = total_iters;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_last_epoch == 0)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * _factor);
							}
							if (_last_epoch == _total_iters)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * (1.0 / _factor));
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							return _base_lrs.Select((double lr) => lr * ((_last_epoch >= _total_iters) ? 1.0 : _factor));
						}
					}

					public class LinearLR : LRScheduler
					{
						private double _start_factor;

						private double _end_factor;

						private int _total_iters;

						public LinearLR(Optimizer optimizer, double start_factor = 1.0 / 3.0, double end_factor = 1.0, int total_iters = 5, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_start_factor = start_factor;
							_end_factor = end_factor;
							_total_iters = total_iters;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_last_epoch == 0)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * _start_factor);
							}
							if (_last_epoch > _total_iters)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
							}
							double factor = 1.0 + (_end_factor - _start_factor) / ((double)_total_iters * _start_factor + (double)(_last_epoch - 1) * (_end_factor - _start_factor));
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate * factor);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							return _base_lrs.Select((double lr) => lr * (_start_factor + (_end_factor - _start_factor) * (double)Math.Min(_total_iters, _last_epoch) / (double)_total_iters));
						}
					}

					public class SequentialLR : LRScheduler
					{
						private LRScheduler[] _schedulers;

						private int[] _milestones;

						public SequentialLR(Optimizer optimizer, IEnumerable<LRScheduler> schedulers, IEnumerable<int> milestones, int last_epoch = -1)
							: base(optimizer, last_epoch + 1)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							foreach (LRScheduler scheduler in schedulers)
							{
								if (scheduler._optimizer != optimizer)
								{
									throw new ArgumentException("The SequentialLR scheduler expects all its sub-schedulers to be bound to the same optimizer.");
								}
							}
							if (milestones.Count() != schedulers.Count() - 1)
							{
								throw new ArgumentException($"Received {schedulers.Count()} schedulers and {milestones.Count()} milestones. The SequentialLR scheduler expects the number of schedulers to be one more than the number of milestones. ");
							}
							_schedulers = schedulers.ToArray();
							_milestones = milestones.ToArray();
							foreach (ILearningRateController paramGroup in optimizer.ParamGroups)
							{
								paramGroup.LearningRate = paramGroup.InitialLearningRate;
							}
							LRScheduler[] schedulers2 = _schedulers;
							for (int i = 0; i < schedulers2.Length; i++)
							{
								schedulers2[i]._last_epoch--;
							}
							_schedulers[0].step();
							_last_lrs = _schedulers[0]._last_lrs;
						}

						protected override IEnumerable<double> get_lr()
						{
							int num = _milestones.Length;
							while (num > 0 && _milestones[num - 1] > _last_epoch)
							{
								num--;
							}
							LRScheduler lRScheduler = _schedulers[num];
							if (num > 0 && _milestones[num - 1] == _last_epoch)
							{
								lRScheduler.step((int?)0);
							}
							else
							{
								lRScheduler.step();
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
						}
					}

					public class CosineAnnealingLR : LRScheduler
					{
						private double _T_max;

						private double _eta_min;

						public CosineAnnealingLR(Optimizer optimizer, double T_max, double eta_min = 0.0, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							_T_max = T_max;
							_eta_min = eta_min;
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							if (_last_epoch == 0)
							{
								return _optimizer.ParamGroups.Select((ILearningRateController pg) => pg.LearningRate);
							}
							if (((double)(_last_epoch - 1) - _T_max) % (2.0 * _T_max) == 0.0)
							{
								List<ILearningRateController> pgs = _optimizer.ParamGroups.ToList();
								return from i in Enumerable.Range(0, pgs.Count)
									select pgs[i].LearningRate + (_base_lrs[i] - _eta_min) * (1.0 - Math.Cos(Math.PI / _T_max)) / 2.0;
							}
							return _optimizer.ParamGroups.Select((ILearningRateController pg) => (1.0 + Math.Cos(Math.PI * (double)_last_epoch / _T_max)) / (1.0 + Math.Cos(Math.PI * (double)(_last_epoch - 1) / _T_max)) * (pg.LearningRate - _eta_min) + _eta_min);
						}

						protected override IEnumerable<double> get_closed_form_lr()
						{
							return _base_lrs.Select((double lr) => _eta_min + (lr - _eta_min) * (1.0 + Math.Cos(Math.PI * (double)_last_epoch / _T_max)) / 2.0);
						}
					}

					public class ReduceLROnPlateau : LRScheduler
					{
						private int patience;

						private int cooldown;

						private int cooldown_counter;

						private string mode;

						private double threshold;

						private string threshold_mode;

						private double best;

						private double mode_worst;

						private int num_bad_epochs;

						private double eps;

						private double factor;

						private List<double> min_lrs;

						public ReduceLROnPlateau(Optimizer optimizer, string mode = "min", double factor = 0.1, int patience = 10, double threshold = 0.0001, string threshold_mode = "rel", int cooldown = 0, IList<double> min_lr = null, double eps = 1E-08, bool verbose = false)
							: base(optimizer, -1, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							if (factor >= 1.0)
							{
								throw new ArgumentException("Factor should be < 1.0");
							}
							if (!(mode == "min") && !(mode == "max"))
							{
								throw new ArgumentException("mode " + mode + " is unknown!");
							}
							if (!(threshold_mode == "rel") && !(threshold_mode == "abs"))
							{
								throw new ArgumentException("threshold mode " + threshold_mode + " is unknown!");
							}
							_optimizer = optimizer;
							this.factor = factor;
							int count = optimizer.ParamGroups.Count();
							if (min_lr == null || min_lr.Count == 0)
							{
								min_lrs = Enumerable.Repeat(0.0, count).ToList();
							}
							else if (min_lr.Count == 1)
							{
								min_lrs = Enumerable.Repeat(min_lr[0], count).ToList();
							}
							else
							{
								min_lrs = min_lr.ToList();
							}
							this.patience = patience;
							this.cooldown = cooldown;
							cooldown_counter = 0;
							this.mode = mode;
							this.threshold = threshold;
							this.threshold_mode = threshold_mode;
							best = -1.0;
							num_bad_epochs = -1;
							this.eps = eps;
							mode_worst = ((mode == "min") ? double.PositiveInfinity : double.NegativeInfinity);
							reset();
						}

						public override void step(double current, int? epoch = null)
						{
							if (!epoch.HasValue)
							{
								epoch = _last_epoch + 1;
							}
							_last_epoch = epoch.Value;
							if (is_better(current, best))
							{
								best = current;
								num_bad_epochs = 0;
							}
							else
							{
								num_bad_epochs++;
							}
							if (cooldown_counter > 0)
							{
								cooldown_counter--;
								num_bad_epochs = 0;
							}
							if (num_bad_epochs > patience)
							{
								reduce_lr(_last_epoch);
								cooldown_counter = cooldown;
								num_bad_epochs = 0;
							}
						}

						public override void step()
						{
							throw new InvalidOperationException("step() should not be used with the ReduceLROnPlateau scheduler. Use step(double, int?), instead.");
						}

						public override void step(int? epoch)
						{
							throw new InvalidOperationException("step(int?) should not be used with the ReduceLROnPlateau scheduler. Use step(double, int?), instead.");
						}

						private bool is_better(double a, double best)
						{
							if (mode == "min" && threshold_mode == "rel")
							{
								return a < best * (1.0 - threshold);
							}
							if (mode == "min" && threshold_mode == "abs")
							{
								return a < best - threshold;
							}
							if (mode == "max" && threshold_mode == "rel")
							{
								return a > best * (threshold + 1.0);
							}
							return a > best + threshold;
						}

						private void reduce_lr(long epoch)
						{
							List<ILearningRateController> list = _optimizer.ParamGroups.ToList();
							for (int i = 0; i < list.Count; i++)
							{
								ILearningRateController learningRateController = list[i];
								double learningRate = learningRateController.LearningRate;
								double num = Math.Max(learningRate * factor, min_lrs[i]);
								if (learningRate - num > eps)
								{
									learningRateController.LearningRate = num;
									if (_verbose)
									{
										Console.WriteLine($"Epoch {epoch}: reducing learning rate of group {i} to {num:g4}.");
									}
								}
							}
						}

						private void reset()
						{
							best = mode_worst;
							cooldown_counter = 0;
							num_bad_epochs = 0;
						}
					}

					public class CyclicLR : LRScheduler
					{
						public enum Mode
						{
							Triangular,
							Triangular2,
							ExpRange
						}

						public enum ScaleMode
						{
							Cycle,
							Iterations
						}

						private double _total_size;

						private double _step_ratio;

						private Func<double, double> _scale_func;

						private ScaleMode _scale_mode;

						private bool _cycle_momentum;

						private List<double> _max_lrs;

						private List<double> _base_momentum;

						private List<double> _max_momentum;

						private Mode _mode;

						private double _gamma;

						public CyclicLR(Optimizer optimizer, double base_lr, double max_lr, int step_size_up = 2000, int step_size_down = -1, Mode mode = Mode.Triangular, double gamma = 1.0, Func<double, double> scale_fn = null, ScaleMode scale_mode = ScaleMode.Cycle, bool cycle_momentum = true, double base_momentum = 0.8, double max_momentum = 0.9, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							int count = optimizer.ParamGroups.Count();
							Initialize(optimizer, Enumerable.Repeat(base_lr, count), Enumerable.Repeat(max_lr, count), step_size_up, step_size_down, mode, gamma, scale_fn, scale_mode, cycle_momentum, Enumerable.Repeat(base_momentum, count), Enumerable.Repeat(max_momentum, count));
						}

						public CyclicLR(Optimizer optimizer, IEnumerable<double> base_lr, IEnumerable<double> max_lr, int step_size_up = 2000, int step_size_down = -1, Mode mode = Mode.Triangular, double gamma = 1.0, Func<double, double> scale_fn = null, ScaleMode scale_mode = ScaleMode.Cycle, bool cycle_momentum = true, IEnumerable<double> base_momentum = null, IEnumerable<double> max_momentum = null, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							Initialize(optimizer, base_lr, max_lr, step_size_up, step_size_down, mode, gamma, scale_fn, scale_mode, cycle_momentum, base_momentum, max_momentum);
						}

						private void Initialize(Optimizer optimizer, IEnumerable<double> base_lr, IEnumerable<double> max_lr, int step_size_up, int step_size_down, Mode mode, double gamma, Func<double, double> scale_fn, ScaleMode scale_mode, bool cycle_momentum, IEnumerable<double> base_momentum, IEnumerable<double> max_momentum)
						{
							double num = ((step_size_down == -1) ? step_size_up : step_size_down);
							_total_size = (double)step_size_up + num;
							_step_ratio = (double)step_size_up / _total_size;
							List<ILearningRateController> list = optimizer.ParamGroups.ToList();
							_max_lrs = max_lr.ToList();
							_base_lrs = base_lr.ToList();
							if (_last_epoch == -1)
							{
								for (int i = 0; i < list.Count; i++)
								{
									list[i].LearningRate = _base_lrs[i];
								}
							}
							_mode = mode;
							_gamma = gamma;
							_cycle_momentum = cycle_momentum;
							if (cycle_momentum)
							{
								if (!(optimizer is IMomentum) && cycle_momentum)
								{
									throw new ArgumentException("optimizer must support momentum with `cycle_momentum` option enabled");
								}
								_base_momentum = ((base_momentum == null) ? Enumerable.Repeat(0.8, list.Count).ToList() : base_momentum.ToList());
								_max_momentum = ((max_momentum == null) ? Enumerable.Repeat(0.9, list.Count).ToList() : max_momentum.ToList());
								if (_last_epoch == -1)
								{
									for (int j = 0; j < list.Count; j++)
									{
										(list[j] as IMomentum).Momentum = _base_momentum[j];
									}
								}
							}
							if (scale_fn == null)
							{
								switch (mode)
								{
								case Mode.Triangular:
									_scale_func = (double x) => 1.0;
									_scale_mode = ScaleMode.Cycle;
									break;
								case Mode.Triangular2:
									_scale_func = (double x) => 1.0 / Math.Pow(2.0, x - 1.0);
									_scale_mode = ScaleMode.Cycle;
									break;
								case Mode.ExpRange:
									_scale_func = (double x) => Math.Pow(_gamma, x);
									_scale_mode = ScaleMode.Cycle;
									break;
								}
							}
							else
							{
								_scale_func = scale_fn;
								_scale_mode = scale_mode;
							}
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							List<ILearningRateController> pgs = _optimizer.ParamGroups.ToList();
							double cycle = Math.Floor(1.0 + (double)_last_epoch / _total_size);
							double num = 1.0 + (double)_last_epoch / _total_size - cycle;
							double scale_factor = ((num <= _step_ratio) ? (num / _step_ratio) : ((num - 1.0) / (_step_ratio - 1.0)));
							return Enumerable.Range(0, pgs.Count).Select(delegate(int i)
							{
								double num2 = (_max_lrs[i] - _base_lrs[i]) * scale_factor;
								double result = ((_scale_mode == ScaleMode.Cycle) ? (_base_lrs[i] + num2 * _scale_func(cycle)) : (_base_lrs[i] + num2 * _scale_func(_last_epoch)));
								if (_cycle_momentum)
								{
									num2 = (_max_momentum[i] - _base_momentum[i]) * scale_factor;
									(pgs[i] as IMomentum).Momentum = ((_scale_mode == ScaleMode.Cycle) ? (_max_momentum[i] + num2 * _scale_func(cycle)) : (_max_momentum[i] + num2 * _scale_func(_last_epoch)));
								}
								return result;
							});
						}
					}

					public class OneCycleLR : LRScheduler
					{
						public enum AnnealStrategy
						{
							Cos,
							Linear
						}

						private class PhaseDescriptor
						{
							public double end_step;

							public string start_lr;

							public string end_lr;

							public string start_momentum;

							public string end_momentum;
						}

						private Func<double, double, double, double> _annealing_func;

						private PhaseDescriptor[] _schedule_phases;

						private Dictionary<string, List<double>> _phase_values = new Dictionary<string, List<double>>();

						private bool _cycle_momentum;

						private List<IBetas> _betas;

						private List<IMomentum> _momentum;

						private int _total_steps;

						public OneCycleLR(Optimizer optimizer, double max_lr, int total_steps = -1, int epochs = -1, int steps_per_epoch = -1, double pct_start = 0.3, AnnealStrategy anneal_strategy = AnnealStrategy.Cos, bool cycle_momentum = true, double base_momentum = 0.85, double max_momentum = 0.95, double div_factor = 25.0, double final_div_factor = 10000.0, bool three_phase = false, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							int count = _optimizer.ParamGroups.Count();
							Initialize(optimizer, Enumerable.Repeat(max_lr, count), total_steps, epochs, steps_per_epoch, pct_start, anneal_strategy, cycle_momentum, Enumerable.Repeat(base_momentum, count), Enumerable.Repeat(max_momentum, count), div_factor, final_div_factor, three_phase, last_epoch);
						}

						public OneCycleLR(Optimizer optimizer, IEnumerable<double> max_lr, int total_steps = -1, int epochs = -1, int steps_per_epoch = -1, double pct_start = 0.3, AnnealStrategy anneal_strategy = AnnealStrategy.Cos, bool cycle_momentum = true, IEnumerable<double> base_momentum = null, IEnumerable<double> max_momentum = null, double div_factor = 25.0, double final_div_factor = 10000.0, bool three_phase = false, int last_epoch = -1, bool verbose = false)
							: base(optimizer, last_epoch, verbose)
						{
							if (optimizer == null)
							{
								throw new ArgumentNullException("optimizer");
							}
							Initialize(optimizer, max_lr, total_steps, epochs, steps_per_epoch, pct_start, anneal_strategy, cycle_momentum, base_momentum, max_momentum, div_factor, final_div_factor, three_phase, last_epoch);
						}

						private void Initialize(Optimizer optimizer, IEnumerable<double> max_lr, int total_steps, int epochs, int steps_per_epoch, double pct_start, AnnealStrategy anneal_strategy, bool cycle_momentum, IEnumerable<double> base_momentum, IEnumerable<double> max_momentum, double div_factor, double final_div_factor, bool three_phase, int last_epoch)
						{
							_cycle_momentum = cycle_momentum;
							List<ILearningRateController> list = optimizer.ParamGroups.ToList();
							if (cycle_momentum)
							{
								IMomentum obj = optimizer as IMomentum;
								IBetas betas = optimizer as IBetas;
								if (obj == null && betas == null)
								{
									throw new ArgumentException("optimizer must support momentum with `cycle_momentum` option enabled");
								}
							}
							if (pct_start < 0.0 || pct_start > 1.0)
							{
								throw new ArgumentException($"Expected float between 0 and 1 for pct_start, but got {pct_start}");
							}
							if (total_steps == -1 && epochs == -1 && steps_per_epoch == -1)
							{
								throw new ArgumentException("You must define either total_steps OR (epochs AND steps_per_epoch)");
							}
							if (total_steps != -1)
							{
								if (total_steps <= 0)
								{
									throw new ArgumentException($"Expected positive integer total_steps, but got {total_steps}");
								}
								_total_steps = total_steps;
							}
							else
							{
								if (epochs <= 0)
								{
									throw new ArgumentException($"Expected positive integer epochs, but got {epochs}");
								}
								if (steps_per_epoch <= 0)
								{
									throw new ArgumentException($"Expected positive integer steps_per_epoch, but got {steps_per_epoch}");
								}
								_total_steps = epochs * steps_per_epoch;
							}
							List<double> value = max_lr.ToList();
							_betas = list.Select((ILearningRateController pg) => pg as IBetas).ToList();
							_momentum = list.Select((ILearningRateController pg) => pg as IMomentum).ToList();
							List<double> list2 = max_lr.Select((double mlr) => mlr / div_factor).ToList();
							_phase_values["initial_lr"] = list2;
							_phase_values["max_lr"] = value;
							_phase_values["min_lr"] = list2.Select((double ilr) => ilr / final_div_factor).ToList();
							_annealing_func = ((anneal_strategy == AnnealStrategy.Cos) ? ((Func<double, double, double, double>)((double start, double end, double pct) => end + (start - end) / 2.0 * (Math.Cos(Math.PI * pct) + 1.0))) : ((Func<double, double, double, double>)((double start, double end, double pct) => (end - start) * pct + start)));
							_schedule_phases = ((!three_phase) ? new PhaseDescriptor[2]
							{
								new PhaseDescriptor
								{
									end_step = pct_start * (double)_total_steps - 1.0,
									start_lr = "initial_lr",
									end_lr = "max_lr",
									start_momentum = "max_momentum",
									end_momentum = "base_momentum"
								},
								new PhaseDescriptor
								{
									end_step = _total_steps - 1,
									start_lr = "max_lr",
									end_lr = "min_lr",
									start_momentum = "base_momentum",
									end_momentum = "max_momentum"
								}
							} : new PhaseDescriptor[3]
							{
								new PhaseDescriptor
								{
									end_step = pct_start * (double)_total_steps - 1.0,
									start_lr = "initial_lr",
									end_lr = "max_lr",
									start_momentum = "max_momentum",
									end_momentum = "base_momentum"
								},
								new PhaseDescriptor
								{
									end_step = 2.0 * pct_start * (double)_total_steps - 2.0,
									start_lr = "max_lr",
									end_lr = "initial_lr",
									start_momentum = "base_momentum",
									end_momentum = "max_momentum"
								},
								new PhaseDescriptor
								{
									end_step = _total_steps - 1,
									start_lr = "initial_lr",
									end_lr = "min_lr",
									start_momentum = "max_momentum",
									end_momentum = "max_momentum"
								}
							});
							if (last_epoch == -1 && cycle_momentum)
							{
								List<double> value2 = ((base_momentum == null) ? Enumerable.Repeat(0.85, list.Count).ToList() : base_momentum.ToList());
								List<double> list3 = ((max_momentum == null) ? Enumerable.Repeat(0.95, list.Count).ToList() : max_momentum.ToList());
								for (int num = 0; num < list.Count; num++)
								{
									if (_betas[num] != null)
									{
										double item = _betas[num].Betas.Item2;
										_betas[num].Betas = (list3[num], item);
									}
									else if (_momentum[num] != null)
									{
										_momentum[num].Momentum = list3[num];
									}
								}
								_phase_values["max_momentum"] = list3;
								_phase_values["base_momentum"] = value2;
							}
							step();
						}

						protected override IEnumerable<double> get_lr()
						{
							int step_num = _last_epoch;
							if (step_num > _total_steps)
							{
								throw new InvalidOperationException($"Tried to step {step_num + 1} times. The specified number of total steps is {_total_steps}");
							}
							List<ILearningRateController> list = _optimizer.ParamGroups.ToList();
							return Enumerable.Range(0, list.Count).Select(delegate(int i)
							{
								double num = 0.0;
								double result = 0.0;
								double num2 = 0.0;
								for (int j = 0; j < _schedule_phases.Length; j++)
								{
									PhaseDescriptor phaseDescriptor = _schedule_phases[j];
									double end_step = phaseDescriptor.end_step;
									if ((double)step_num <= end_step || i == _schedule_phases.Length - 1)
									{
										double arg = ((double)step_num - num) / (end_step - num);
										result = _annealing_func(_phase_values[phaseDescriptor.start_lr][i], _phase_values[phaseDescriptor.end_lr][i], arg);
										if (_cycle_momentum)
										{
											num2 = _annealing_func(_phase_values[phaseDescriptor.start_momentum][i], _phase_values[phaseDescriptor.end_momentum][i], arg);
										}
										break;
									}
									num = phaseDescriptor.end_step;
								}
								if (_cycle_momentum)
								{
									if (_betas[i] != null)
									{
										double item = _betas[i].Betas.Item2;
										_betas[i].Betas = (num2, item);
									}
									else
									{
										_momentum[i].Momentum = num2;
									}
								}
								return result;
							});
						}
					}

					public class ChainedLR : LRScheduler
					{
						private IEnumerable<LRScheduler> _schedulers;

						public ChainedLR(IEnumerable<LRScheduler> schedulers)
						{
							_schedulers = schedulers;
						}

						public override void step()
						{
							foreach (LRScheduler scheduler in _schedulers)
							{
								scheduler.step();
							}
						}
					}
				}

				public static LRScheduler StepLR(Optimizer optimizer, int step_size, double gamma = 0.1, int last_epoch = -1, bool verbose = false)
				{
					return new impl.StepLR(optimizer, step_size, gamma, last_epoch, verbose);
				}

				public static LRScheduler LambdaLR(Optimizer optimizer, Func<int, double> lr_lambda, int last_epoch = -1, bool verbose = false)
				{
					return new impl.LambdaLR(optimizer, lr_lambda, last_epoch, verbose);
				}

				public static LRScheduler MultiStepLR(Optimizer optimizer, IList<int> milestones, double gamma = 0.1, int last_epoch = -1, bool verbose = false)
				{
					return new impl.MultiStepLR(optimizer, milestones, gamma, last_epoch, verbose);
				}

				public static LRScheduler PolynomialLR(Optimizer optimizer, int total_iters = 5, double power = 1.0, int last_epoch = -1, bool verbose = false)
				{
					return new impl.PolynomialLR(optimizer, total_iters, power, last_epoch, verbose);
				}

				public static LRScheduler MultiplicativeLR(Optimizer optimizer, Func<int, double> lr_lambda, int last_epoch = -1, bool verbose = false)
				{
					return new impl.MultiplicativeLR(optimizer, lr_lambda, last_epoch, verbose);
				}

				public static LRScheduler ExponentialLR(Optimizer optimizer, double gamma = 0.1, int last_epoch = -1, bool verbose = false)
				{
					return new impl.ExponentialLR(optimizer, gamma, last_epoch, verbose);
				}

				public static LRScheduler ConstantLR(Optimizer optimizer, double factor = 1.0 / 3.0, int total_iters = 5, int last_epoch = -1, bool verbose = false)
				{
					return new impl.ConstantLR(optimizer, factor, total_iters, last_epoch, verbose);
				}

				public static LRScheduler SequentialLR(Optimizer optimizer, IEnumerable<LRScheduler> schedulers, IEnumerable<int> milestones, int last_epoch = -1)
				{
					return new impl.SequentialLR(optimizer, schedulers, milestones, last_epoch);
				}

				public static LRScheduler LinearLR(Optimizer optimizer, double start_factor = 1.0 / 3.0, double end_factor = 1.0, int total_iters = 5, int last_epoch = -1, bool verbose = false)
				{
					return new impl.LinearLR(optimizer, start_factor, end_factor, total_iters, last_epoch, verbose);
				}

				public static LRScheduler ChainedLR(IEnumerable<LRScheduler> schedulers)
				{
					return new impl.ChainedLR(schedulers);
				}

				public static LRScheduler CosineAnnealingLR(Optimizer optimizer, double T_max, double eta_min = 0.0, int last_epoch = -1, bool verbose = false)
				{
					return new impl.CosineAnnealingLR(optimizer, T_max, eta_min, last_epoch, verbose);
				}

				public static LRScheduler OneCycleLR(Optimizer optimizer, double max_lr, int total_steps = -1, int epochs = -1, int steps_per_epoch = -1, double pct_start = 0.3, impl.OneCycleLR.AnnealStrategy anneal_strategy = impl.OneCycleLR.AnnealStrategy.Cos, bool cycle_momentum = true, double base_momentum = 0.85, double max_momentum = 0.95, double div_factor = 25.0, double final_div_factor = 10000.0, bool three_phase = false, int last_epoch = -1, bool verbose = false)
				{
					return new impl.OneCycleLR(optimizer, max_lr, total_steps, epochs, steps_per_epoch, pct_start, anneal_strategy, cycle_momentum, base_momentum, max_momentum, div_factor, final_div_factor, three_phase, last_epoch, verbose);
				}

				public static LRScheduler OneCycleLR(Optimizer optimizer, IEnumerable<double> max_lr, int total_steps = -1, int epochs = -1, int steps_per_epoch = -1, double pct_start = 0.3, impl.OneCycleLR.AnnealStrategy anneal_strategy = impl.OneCycleLR.AnnealStrategy.Cos, bool cycle_momentum = true, IEnumerable<double> base_momentum = null, IEnumerable<double> max_momentum = null, double div_factor = 25.0, double final_div_factor = 10000.0, bool three_phase = false, int last_epoch = -1, bool verbose = false)
				{
					return new impl.OneCycleLR(optimizer, max_lr, total_steps, epochs, steps_per_epoch, pct_start, anneal_strategy, cycle_momentum, base_momentum, max_momentum, div_factor, final_div_factor, three_phase, last_epoch, verbose);
				}

				public static LRScheduler CyclicLR(Optimizer optimizer, double base_lr, double max_lr, int step_size_up = 2000, int step_size_down = -1, impl.CyclicLR.Mode mode = impl.CyclicLR.Mode.Triangular, double gamma = 1.0, Func<double, double> scale_fn = null, impl.CyclicLR.ScaleMode scale_mode = impl.CyclicLR.ScaleMode.Cycle, bool cycle_momentum = true, double base_momentum = 0.8, double max_momentum = 0.9, int last_epoch = -1, bool verbose = false)
				{
					return new impl.CyclicLR(optimizer, base_lr, max_lr, step_size_up, step_size_down, mode, gamma, scale_fn, scale_mode, cycle_momentum, base_momentum, max_momentum, last_epoch, verbose);
				}

				public static LRScheduler CyclicLR(Optimizer optimizer, IEnumerable<double> base_lr, IEnumerable<double> max_lr, int step_size_up = 2000, int step_size_down = -1, impl.CyclicLR.Mode mode = impl.CyclicLR.Mode.Triangular, double gamma = 1.0, Func<double, double> scale_fn = null, impl.CyclicLR.ScaleMode scale_mode = impl.CyclicLR.ScaleMode.Cycle, bool cycle_momentum = true, IEnumerable<double> base_momentum = null, IEnumerable<double> max_momentum = null, int last_epoch = -1, bool verbose = false)
				{
					return new impl.CyclicLR(optimizer, base_lr, max_lr, step_size_up, step_size_down, mode, gamma, scale_fn, scale_mode, cycle_momentum, base_momentum, max_momentum, last_epoch, verbose);
				}

				public static LRScheduler ReduceLROnPlateau(Optimizer optimizer, string mode = "min", double factor = 0.1, int patience = 10, double threshold = 0.0001, string threshold_mode = "rel", int cooldown = 0, IList<double> min_lr = null, double eps = 1E-08, bool verbose = false)
				{
					return new impl.ReduceLROnPlateau(optimizer, mode, factor, patience, threshold, threshold_mode, cooldown, min_lr, eps, verbose);
				}
			}

			public abstract class Optimizer : IDisposable
			{
				internal sealed class HType : SafeHandle
				{
					public override bool IsInvalid => handle == IntPtr.Zero;

					public HType(IntPtr preexistingHandle, bool ownsHandle)
						: base(IntPtr.Zero, ownsHandle)
					{
						SetHandle(preexistingHandle);
					}

					internal HType()
						: base(IntPtr.Zero, ownsHandle: true)
					{
					}

					protected override bool ReleaseHandle()
					{
						NativeMethods.THSNN_Optimizer_dispose(this);
						return true;
					}

					protected override void Dispose(bool disposing)
					{
						if (disposing)
						{
							ReleaseHandle();
						}
					}
				}

				[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
				public delegate IntPtr LossClosure();

				public class StateDictionary
				{
					public List<TorchSharp.Modules.OptimizerOptions> Options { get; private set; }

					public List<OptimizerState> State { get; private set; }

					public List<List<int>> StateIndexRef { get; private set; }

					internal StateDictionary()
					{
						Options = new List<TorchSharp.Modules.OptimizerOptions>();
						State = new List<OptimizerState>();
						StateIndexRef = new List<List<int>>();
					}
				}

				internal HType handle;

				protected IList<ParamGroup> _parameter_groups;

				public virtual IEnumerable<ILearningRateController> ParamGroups => _parameter_groups;

				protected Optimizer(IntPtr handle)
				{
					if (handle != IntPtr.Zero)
					{
						this.handle = new HType(handle, ownsHandle: true);
					}
				}

				~Optimizer()
				{
					Dispose(disposing: false);
				}

				public void Dispose()
				{
					Dispose(disposing: true);
					GC.SuppressFinalize(this);
				}

				protected virtual void Dispose(bool disposing)
				{
					if (disposing && handle != null && !handle.IsInvalid)
					{
						handle.Dispose();
						handle.SetHandleAsInvalid();
					}
				}

				public virtual void zero_grad()
				{
					NativeMethods.THSNN_Optimizer_zero_grad(handle);
					CheckForErrors();
				}

				public virtual void add_param_group(ParamGroup param_group)
				{
					throw new NotImplementedException("add_param_group");
				}

				public virtual Tensor step(Func<Tensor> closure = null)
				{
					IntPtr intPtr = ((closure == null) ? NativeMethods.THSNN_Optimizer_step(handle, null) : NativeMethods.THSNN_Optimizer_step(handle, () => closure().DecoupleFromNativeHandle()));
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					if (!(intPtr == IntPtr.Zero))
					{
						return new Tensor(intPtr);
					}
					return null;
				}

				public virtual IEnumerable<Parameter> parameters()
				{
					IntPtr[] array;
					using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
					{
						NativeMethods.THSNN_Optimizer_getParameters(handle, pinnedArray.CreateArray);
						CheckForErrors();
						array = pinnedArray.Array;
					}
					return array.Select((IntPtr x) => new Parameter(x));
				}
			}

			public interface ILearningRateController
			{
				double LearningRate { get; set; }

				double InitialLearningRate { get; set; }
			}

			public interface IMomentum
			{
				double Momentum { get; set; }
			}

			public interface IBetas
			{
				(double, double) Betas { get; set; }
			}

			public static Adadelta Adadelta(IEnumerable<Parameter> parameters, double lr = 1.0, double rho = 0.9, double eps = 1E-06, double weight_decay = 0.0, bool maximize = false)
			{
				return new Adadelta(parameters, lr, rho, eps, weight_decay, maximize);
			}

			public static Adadelta Adadelta(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 1.0, double rho = 0.9, double eps = 1E-06, double weight_decay = 0.0, bool maximize = false)
			{
				return new Adadelta(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, rho, eps, weight_decay, maximize);
			}

			public static Adadelta Adadelta(IEnumerable<Adadelta.ParamGroup> parameters, double lr = 1.0, double rho = 0.9, double eps = 1E-06, double weight_decay = 0.0, bool maximize = false)
			{
				return new Adadelta(parameters, lr, rho, eps, weight_decay, maximize);
			}

			public static Adagrad Adagrad(IEnumerable<Parameter> parameters, double lr = 0.01, double lr_decay = 0.0, double weight_decay = 0.0, double initial_accumulator_value = 0.0, double eps = 1E-10)
			{
				return new Adagrad(parameters, lr, lr_decay, weight_decay, initial_accumulator_value, eps);
			}

			public static Adagrad Adagrad(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.01, double lr_decay = 0.0, double weight_decay = 0.0, double initial_accumulator_value = 0.0, double eps = 1E-10)
			{
				return new Adagrad(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, lr_decay, weight_decay, initial_accumulator_value, eps);
			}

			public static Adagrad Adagrad(IEnumerable<Adagrad.ParamGroup> parameters, double lr = 0.01, double lr_decay = 0.0, double weight_decay = 0.0, double initial_accumulator_value = 0.0, double eps = 1E-10)
			{
				return new Adagrad(parameters, lr, lr_decay, weight_decay, initial_accumulator_value, eps);
			}

			public static Adam Adam(IEnumerable<Parameter> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			{
				return new Adam(parameters, lr, beta1, beta2, eps, weight_decay, amsgrad, maximize);
			}

			public static Adam Adam(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			{
				return new Adam(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, beta1, beta2, eps, weight_decay, amsgrad, maximize);
			}

			public static Adam Adam(IEnumerable<Adam.ParamGroup> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			{
				return new Adam(parameters, lr, beta1, beta2, eps, weight_decay, amsgrad, maximize);
			}

			public static Adamax Adamax(IEnumerable<Parameter> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			{
				return new Adamax(parameters, lr, beta1, beta2, eps, weight_decay);
			}

			public static Adamax Adamax(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			{
				return new Adamax(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, beta1, beta2, eps, weight_decay);
			}

			public static Adamax Adamax(IEnumerable<Adamax.ParamGroup> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			{
				return new Adamax(parameters, lr, beta1, beta2, eps, weight_decay);
			}

			public static AdamW AdamW(IEnumerable<Parameter> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			{
				return new AdamW(parameters, lr, beta1, beta2, eps, weight_decay, amsgrad, maximize);
			}

			public static AdamW AdamW(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			{
				return new AdamW(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, beta1, beta2, eps, weight_decay, amsgrad, maximize);
			}

			public static AdamW AdamW(IEnumerable<AdamW.ParamGroup> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			{
				return new AdamW(parameters, lr, beta1, beta2, eps, weight_decay, amsgrad, maximize);
			}

			public static ASGD ASGD(IEnumerable<Parameter> parameters, double lr = 0.001, double lambd = 0.0001, double alpha = 0.75, double t0 = 1000000.0, double weight_decay = 0.0, bool maximize = false)
			{
				return new ASGD(parameters, lr, lambd, alpha, t0, weight_decay, maximize);
			}

			public static ASGD ASGD(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.001, double lambd = 0.0001, double alpha = 0.75, double t0 = 1000000.0, double weight_decay = 0.0, bool maximize = false)
			{
				return new ASGD(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, lambd, alpha, t0, weight_decay, maximize);
			}

			public static ASGD ASGD(IEnumerable<ParamGroup<ASGD.Options>> parameters, double lr = 0.001, double lambd = 0.0001, double alpha = 0.75, double t0 = 1000000.0, double weight_decay = 0.0, bool maximize = false)
			{
				return new ASGD(parameters, lr, lambd, alpha, t0, weight_decay, maximize);
			}

			public static LBFGS LBFGS(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.01, long max_iter = 20L, long? max_eval = null, double tolerange_grad = 1E-05, double tolerance_change = 1E-09, long history_size = 100L)
			{
				return LBFGS(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, max_iter, max_eval.Value, tolerange_grad, tolerance_change, history_size);
			}

			public static LBFGS LBFGS(IEnumerable<Parameter> parameters, double lr = 0.01, long max_iter = 20L, long? max_eval = null, double tolerange_grad = 1E-05, double tolerance_change = 1E-09, long history_size = 100L)
			{
				if (!max_eval.HasValue)
				{
					max_eval = 5 * max_iter / 4;
				}
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = NativeMethods.THSNN_LBFGS_ctor(pinnedArray.CreateArray(parameters.ToHandleArray()), pinnedArray.Array.Length, lr, max_iter, max_eval.Value, tolerange_grad, tolerance_change, history_size);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new LBFGS(intPtr, lr);
			}

			public static NAdam NAdam(IEnumerable<Parameter> named_parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, double momentum_decay = 0.004)
			{
				return new NAdam(named_parameters, lr, beta1, beta2, eps, weight_decay, momentum_decay);
			}

			public static NAdam NAdam(IEnumerable<(string name, Parameter parameter)> named_parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, double momentum_decay = 0.004)
			{
				return new NAdam(named_parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, beta1, beta2, eps, weight_decay, momentum_decay);
			}

			public static NAdam NAdam(IEnumerable<NAdam.ParamGroup> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, double momentum_decay = 0.004)
			{
				return new NAdam(parameters, lr, beta1, beta2, eps, weight_decay, momentum_decay);
			}

			public static RAdam RAdam(IEnumerable<Parameter> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			{
				return new RAdam(parameters, lr, beta1, beta2, eps, weight_decay);
			}

			public static RAdam RAdam(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			{
				return new RAdam(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, beta1, beta2, eps, weight_decay);
			}

			public static RAdam RAdam(IEnumerable<RAdam.ParamGroup> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			{
				return new RAdam(parameters, lr, beta1, beta2, eps, weight_decay);
			}

			public static RMSProp RMSProp(IEnumerable<Parameter> parameters, double lr = 0.01, double alpha = 0.99, double eps = 1E-08, double weight_decay = 0.0, double momentum = 0.0, bool centered = false, bool maximize = false)
			{
				return new RMSProp(parameters, lr, alpha, eps, weight_decay, momentum, centered, maximize);
			}

			public static RMSProp RMSProp(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.01, double alpha = 0.99, double eps = 1E-08, double weight_decay = 0.0, double momentum = 0.0, bool centered = false, bool maximize = false)
			{
				return new RMSProp(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, alpha, eps, weight_decay, momentum, centered, maximize);
			}

			public static RMSProp RMSProp(IEnumerable<RMSProp.ParamGroup> parameters, double lr = 0.01, double alpha = 0.99, double eps = 1E-08, double weight_decay = 0.0, double momentum = 0.0, bool centered = false, bool maximize = false)
			{
				return new RMSProp(parameters, lr, alpha, eps, weight_decay, momentum, centered, maximize);
			}

			public static Rprop Rprop(IEnumerable<Parameter> parameters, double lr = 0.01, double etaminus = 0.5, double etaplus = 1.2, double min_step = 1E-06, double max_step = 50.0, bool maximize = false)
			{
				return new Rprop(parameters, lr, etaminus, etaplus, min_step, max_step, maximize);
			}

			public static Rprop Rprop(IEnumerable<(string name, Parameter parameter)> parameters, double lr = 0.01, double etaminus = 0.5, double etaplus = 1.2, double min_step = 1E-06, double max_step = 50.0, bool maximize = false)
			{
				return new Rprop(parameters.Select(((string name, Parameter parameter) np) => np.parameter), lr, etaminus, etaplus, min_step, max_step, maximize);
			}

			public static Rprop Rprop(IEnumerable<Rprop.ParamGroup> parameters, double lr = 0.01, double etaminus = 0.5, double etaplus = 1.2, double min_step = 1E-06, double max_step = 50.0, bool maximize = false)
			{
				return new Rprop(parameters, lr, etaminus, etaplus, min_step, max_step, maximize);
			}

			public static SGD SGD(IEnumerable<Parameter> parameters, double learningRate, double momentum = 0.0, double dampening = 0.0, double weight_decay = 0.0, bool nesterov = false, bool maximize = false)
			{
				return new SGD(parameters, learningRate, momentum, dampening, weight_decay, nesterov, maximize);
			}

			public static SGD SGD(IEnumerable<(string name, Parameter parameter)> parameters, double learningRate, double momentum = 0.0, double dampening = 0.0, double weight_decay = 0.0, bool nesterov = false, bool maximize = false)
			{
				return new SGD(parameters.Select(((string name, Parameter parameter) np) => np.parameter), learningRate, momentum, dampening, weight_decay, nesterov, maximize);
			}

			public static SGD SGD(IEnumerable<SGD.ParamGroup> parameters, double learningRate, double momentum = 0.0, double dampening = 0.0, double weight_decay = 0.0, bool nesterov = false, bool maximize = false)
			{
				return new SGD(parameters, learningRate, momentum, dampening, weight_decay, nesterov, maximize);
			}
		}

		public static class special
		{
			public static Tensor airy_ai(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_airy_ai(input.Handle) : NativeMethods.THSSpecial_airy_ai_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor bessel_j0(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_bessel_j0(input.Handle) : NativeMethods.THSSpecial_bessel_j0_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor bessel_j1(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_bessel_j1(input.Handle) : NativeMethods.THSSpecial_bessel_j1_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor bessel_y0(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_bessel_y0(input.Handle) : NativeMethods.THSSpecial_bessel_y0_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor bessel_y1(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_bessel_y1(input.Handle) : NativeMethods.THSSpecial_bessel_y1_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor modified_bessel_i0(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_modified_bessel_i0(input.Handle) : NativeMethods.THSSpecial_modified_bessel_i0_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor modified_bessel_i1(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_modified_bessel_i1(input.Handle) : NativeMethods.THSSpecial_modified_bessel_i1_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor modified_bessel_k0(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_modified_bessel_k0(input.Handle) : NativeMethods.THSSpecial_modified_bessel_k0_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor modified_bessel_k1(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_modified_bessel_k1(input.Handle) : NativeMethods.THSSpecial_modified_bessel_k1_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor scaled_modified_bessel_k0(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_scaled_modified_bessel_k0(input.Handle) : NativeMethods.THSSpecial_scaled_modified_bessel_k0_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor scaled_modified_bessel_k1(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_scaled_modified_bessel_k1(input.Handle) : NativeMethods.THSSpecial_scaled_modified_bessel_k1_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor spherical_bessel_j0(Tensor input, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_spherical_bessel_j0(input.Handle) : NativeMethods.THSSpecial_spherical_bessel_j0_out(input.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor chebyshev_polynomial_t(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_chebyshev_polynomial_t(x.Handle, n.Handle) : NativeMethods.THSSpecial_chebyshev_polynomial_t_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor chebyshev_polynomial_u(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_chebyshev_polynomial_u(x.Handle, n.Handle) : NativeMethods.THSSpecial_chebyshev_polynomial_u_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor chebyshev_polynomial_v(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_chebyshev_polynomial_v(x.Handle, n.Handle) : NativeMethods.THSSpecial_chebyshev_polynomial_v_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor chebyshev_polynomial_w(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_chebyshev_polynomial_w(x.Handle, n.Handle) : NativeMethods.THSSpecial_chebyshev_polynomial_w_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor shifted_chebyshev_polynomial_t(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_shifted_chebyshev_polynomial_t(x.Handle, n.Handle) : NativeMethods.THSSpecial_shifted_chebyshev_polynomial_t_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor shifted_chebyshev_polynomial_u(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_shifted_chebyshev_polynomial_u(x.Handle, n.Handle) : NativeMethods.THSSpecial_shifted_chebyshev_polynomial_u_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor shifted_chebyshev_polynomial_v(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_shifted_chebyshev_polynomial_v(x.Handle, n.Handle) : NativeMethods.THSSpecial_shifted_chebyshev_polynomial_v_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor shifted_chebyshev_polynomial_w(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_shifted_chebyshev_polynomial_w(x.Handle, n.Handle) : NativeMethods.THSSpecial_shifted_chebyshev_polynomial_w_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor hermite_polynomial_h(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_hermite_polynomial_h(x.Handle, n.Handle) : NativeMethods.THSSpecial_hermite_polynomial_h_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor hermite_polynomial_he(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_hermite_polynomial_he(x.Handle, n.Handle) : NativeMethods.THSSpecial_hermite_polynomial_he_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor laguerre_polynomial_l(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_laguerre_polynomial_l(x.Handle, n.Handle) : NativeMethods.THSSpecial_laguerre_polynomial_l_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor legendre_polynomial_p(Tensor x, Tensor n, Tensor? @out = null)
			{
				IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSSpecial_legendre_polynomial_p(x.Handle, n.Handle) : NativeMethods.THSSpecial_legendre_polynomial_p_out(x.Handle, n.Handle, @out.Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor entr(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_entr(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor erf(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_erf(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor erfc(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_erfc(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor erfcx(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_erfc(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor erfinv(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_erfinv(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor expit(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_expit(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor expm1(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_expm1(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor exp2(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_exp2(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor gammaln(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_gammaln(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor gammainc(Tensor input, Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_gammainc(input.Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor gammaincc(Tensor input, Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_gammaincc(input.Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor polygamma(long n, Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_polygamma(n, input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor multigammaln(Tensor input, long p)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_multigammaln(input.Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor digamma(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_digamma(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor psi(Tensor input)
			{
				return digamma(input);
			}

			public static Tensor i0(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_i0(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor i0e(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_i0e(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor i1(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_i1(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor i1e(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_i1e(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor logit(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_logit(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor log_softmax(Tensor input, long dim, ScalarType? dtype = null)
			{
				ScalarType scalar_type = (dtype.HasValue ? dtype.Value : input.dtype);
				IntPtr intPtr = NativeMethods.THSSpecial_log_softmax(input.Handle, dim, (sbyte)scalar_type);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor ndtr(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_ndtr(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor ndtri(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_ndtri(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor sinc(Tensor input)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_sinc(input.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor sigmoid(Tensor input)
			{
				return input.sigmoid();
			}

			public static Tensor sigmoid_(Tensor input)
			{
				return input.sigmoid_();
			}

			public static Tensor softmax(Tensor input, long dim, ScalarType? dtype = null)
			{
				ScalarType scalar_type = (dtype.HasValue ? dtype.Value : input.dtype);
				IntPtr intPtr = NativeMethods.THSSpecial_softmax(input.Handle, dim, (sbyte)scalar_type);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor xlog1py(Tensor input, Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_xlog1py(input.Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor zeta(Tensor x, Tensor q)
			{
				IntPtr intPtr = NativeMethods.THSSpecial_zeta(x.Handle, q.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}
		}

		[TypeFormatterSource(typeof(TypeFormatterSource))]
		public class Tensor : IDisposable
		{
			internal IntPtr handle;

			private static long _totalCount;

			private static long _peakCount;

			private string?[]? _names;

			private const double one_eighth = 0.125;

			private const double one_third = 1.0 / 3.0;

			private const string ellipsis = "...";

			internal DisposeScope? OwningDisposeScope { get; set; }

			public string? name { get; set; }

			public bool IsInvalid => handle == IntPtr.Zero;

			public static long TotalCount => _totalCount;

			public static long PeakCount => _peakCount;

			public IntPtr Handle
			{
				get
				{
					if (handle == IntPtr.Zero)
					{
						throw new InvalidOperationException("Tensor invalid -- empty handle.");
					}
					return handle;
				}
			}

			public long Dimensions => NativeMethods.THSTensor_ndimension(Handle);

			public long ndim => Dimensions;

			public long NumberOfElements => NativeMethods.THSTensor_numel(Handle);

			public long ElementSize => NativeMethods.THSTensor_element_size(Handle);

			public bool is_cuda => device.type == DeviceType.CUDA;

			public bool is_meta => device.type == DeviceType.META;

			public bool is_leaf => NativeMethods.THSTensor_is_leaf(Handle) != 0;

			public unsafe Span<byte> bytes
			{
				get
				{
					long num = NumberOfElements * ElementSize;
					_validate(num);
					IntPtr intPtr = NativeMethods.THSTensor_data(handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Span<byte>((void*)intPtr, (int)num);
				}
				set
				{
					long num = NumberOfElements * ElementSize;
					if (!is_contiguous())
					{
						throw new InvalidOperationException("SetBytes() called on non-contiguous tensor.");
					}
					if (num != value.Length)
					{
						throw new ArgumentException("Mismatched data sizes in SetBytes().");
					}
					IntPtr intPtr = NativeMethods.THSTensor_data(handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					Span<byte> destination = new Span<byte>((void*)intPtr, value.Length);
					value.CopyTo(destination);
				}
			}

			public Tensor real
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_real(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor imag
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_imag(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public ScalarType dtype => (ScalarType)NativeMethods.THSTensor_type(Handle);

			public Device device
			{
				get
				{
					DeviceType deviceType = device_type;
					if (deviceType == DeviceType.CPU)
					{
						return new Device(DeviceType.CPU);
					}
					return new Device(deviceType, device_index);
				}
			}

			public int device_index
			{
				get
				{
					int result = NativeMethods.THSTensor_device_index(Handle);
					CheckForErrors();
					return result;
				}
			}

			public DeviceType device_type
			{
				get
				{
					int result = NativeMethods.THSTensor_device_type(Handle);
					CheckForErrors();
					return (DeviceType)result;
				}
			}

			public bool is_sparse
			{
				get
				{
					bool result = NativeMethods.THSTensor_is_sparse(Handle);
					CheckForErrors();
					return result;
				}
			}

			public bool requires_grad
			{
				get
				{
					return NativeMethods.THSTensor_requires_grad(Handle);
				}
				set
				{
					NativeMethods.THSTensor_set_requires_grad(Handle, value);
					CheckForErrors();
				}
			}

			public long[] shape => size();

			public string[] names
			{
				get
				{
					if (_names != null)
					{
						return _names;
					}
					if (!NativeMethods.THSTensor_has_names(Handle))
					{
						_names = new string[ndim];
						return _names;
					}
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					NativeMethods.THSTensor_names(Handle, pinnedArray.CreateArray);
					CheckForErrors();
					IntPtr[] array = pinnedArray.Array;
					if (array == null)
					{
						_names = new string[ndim];
						return _names;
					}
					_names = array.Select(delegate(IntPtr str)
					{
						string text = Marshal.PtrToStringAnsi(str);
						return (!(text == "*")) ? text : null;
					}).ToArray();
					return _names;
				}
			}

			public Tensor SparseIndices
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_indices(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor SparseValues
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_values(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor? grad
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_grad(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
						return null;
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set_grad(Handle, value?.Handle ?? IntPtr.Zero);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[params TensorIndex[] indices]
			{
				get
				{
					return index(indices);
				}
				set
				{
					index_put_(value, indices);
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[params Tensor[] indices]
			{
				get
				{
					return index(indices);
				}
				set
				{
					index_put_(value, indices);
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[long i1]
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_get1(Handle, i1);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set1(Handle, i1, value.Handle);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[long i1, long i2]
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_get2(Handle, i1, i2);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set2(Handle, i1, i2, value.Handle);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[long i1, long i2, long i3]
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_get3(Handle, i1, i2, i3);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set3(Handle, i1, i2, i3, value.Handle);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[long i1, long i2, long i3, long i4]
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_get4(Handle, i1, i2, i3, i4);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set4(Handle, i1, i2, i3, i4, value.Handle);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[long i1, long i2, long i3, long i4, long i5]
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_get5(Handle, i1, i2, i3, i4, i5);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set5(Handle, i1, i2, i3, i4, i5, value.Handle);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[long i1, long i2, long i3, long i4, long i5, long i6]
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_get6(Handle, i1, i2, i3, i4, i5, i6);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
				set
				{
					NativeMethods.THSTensor_set6(Handle, i1, i2, i3, i4, i5, i6, value.Handle);
					CheckForErrors();
				}
			}

			[IndexerName("TensorItems")]
			public Tensor this[params long[] indices]
			{
				get
				{
					return index(indices.Select((long t) => TensorIndex.Single(t)).ToArray());
				}
				set
				{
					index_put_(value, indices.Select((long t) => TensorIndex.Single(t)).ToArray());
				}
			}

			public Tensor T => permute(Enumerable.Range(0, (int)ndim).Reverse().Select((Func<int, long>)((int i) => i))
				.ToArray());

			public Tensor H
			{
				get
				{
					if (!is_complex())
					{
						return transpose(0L, 1L);
					}
					return transpose(0L, 1L).conj();
				}
			}

			public Tensor mT
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_mT(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor mH
			{
				get
				{
					IntPtr intPtr = NativeMethods.THSTensor_mH(Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public static Tensor Load(BinaryReader reader)
			{
				ScalarType value = (ScalarType)reader.Decode();
				long num = reader.Decode();
				long[] array = new long[num];
				long num2 = 1L;
				for (int i = 0; i < num; i++)
				{
					array[i] = reader.Decode();
					num2 *= array[i];
				}
				if (num2 > int.MaxValue)
				{
					throw new NotImplementedException("Loading tensors larger than 2GB");
				}
				Tensor tensor = torch.empty(array, (ScalarType?)value, (Device?)null, requires_grad: false, (string[]?)null);
				tensor.ReadBytesFromStream(reader.BaseStream);
				return tensor;
			}

			public static Tensor Load(Stream stream)
			{
				using BinaryReader reader = new BinaryReader(stream);
				return Load(reader);
			}

			public static Tensor Load(string location)
			{
				if (!File.Exists(location))
				{
					throw new FileNotFoundException(location);
				}
				using FileStream stream = File.OpenRead(location);
				return Load(stream);
			}

			internal Tensor(IntPtr handle, bool register = true)
			{
				this.handle = handle;
				Interlocked.Increment(ref _totalCount);
				_peakCount = Math.Max(_totalCount, _peakCount);
				if (register)
				{
					OwningDisposeScope = DisposeScopeManager.ThreadSingleton.RegisterOnCurrentDisposeScope(this);
				}
			}

			public static Tensor UnsafeCreateTensor(IntPtr handle)
			{
				return new Tensor(handle);
			}

			public override bool Equals(object? obj)
			{
				if (obj is Tensor)
				{
					return Equals(obj as Tensor);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return base.GetHashCode();
			}

			~Tensor()
			{
				Dispose(disposing: false);
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			protected virtual void Dispose(bool disposing)
			{
				if (handle != IntPtr.Zero)
				{
					DisposeScopeManager.ThreadSingleton.DisposingOnCurrentScope(this);
					OwningDisposeScope?.MarkAsDisposed(this);
					Interlocked.Decrement(ref _totalCount);
					NativeMethods.THSTensor_dispose(handle);
					handle = IntPtr.Zero;
				}
			}

			public Tensor MoveToOuterDisposeScope()
			{
				OwningDisposeScope?.MoveToOuter(this);
				return this;
			}

			public Tensor DetachFromDisposeScope()
			{
				OwningDisposeScope?.Detach(this);
				return this;
			}

			public Tensor MoveToOtherDisposeScope(Tensor other)
			{
				return MoveToOtherDisposeScope(other.OwningDisposeScope);
			}

			public Tensor MoveToOtherDisposeScope(DisposeScope? other)
			{
				if (OwningDisposeScope == null && other != null)
				{
					other.Attach(this);
				}
				else
				{
					OwningDisposeScope?.MoveToOther(other, this);
				}
				return this;
			}

			[Obsolete("The method name misspells 'Detach.' Use 'DetachFromDisposeScope' instead.", false)]
			public Tensor DetatchFromDisposeScope()
			{
				return DetachFromDisposeScope();
			}

			public IntPtr DecoupleFromNativeHandle()
			{
				GC.SuppressFinalize(this);
				if (handle == IntPtr.Zero)
				{
					throw new InvalidOperationException("Tensor invalid -- empty handle.");
				}
				Interlocked.Decrement(ref _totalCount);
				IntPtr result = handle;
				handle = IntPtr.Zero;
				return result;
			}

			internal IntPtr MoveHandle()
			{
				IntPtr result = handle;
				handle = IntPtr.Zero;
				return result;
			}

			public long dim()
			{
				return Dimensions;
			}

			public long numel()
			{
				return NumberOfElements;
			}

			public long element_size()
			{
				return NativeMethods.THSTensor_element_size(Handle);
			}

			public bool is_integral()
			{
				return torch.is_integral(dtype);
			}

			public bool is_floating_point()
			{
				return torch.is_floating_point(dtype);
			}

			public bool is_complex()
			{
				return torch.is_complex(dtype);
			}

			public bool is_nonzero()
			{
				if (numel() != 1)
				{
					throw new InvalidOperationException("is_nonzero() called on non-singleton tensor");
				}
				long num = NativeMethods.THSTensor_is_nonzero(Handle);
				CheckForErrors();
				return num != 0;
			}

			public Tensor alias()
			{
				IntPtr intPtr = NativeMethods.THSTensor_alias(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Storage<T> storage<T>() where T : unmanaged
			{
				return Storage.Create<T>(this);
			}

			public long storage_offset()
			{
				long result = NativeMethods.THSTensor_storage_offset(Handle);
				CheckForErrors();
				return result;
			}

			public TensorAccessor<T> data<T>() where T : unmanaged
			{
				ValidateType(typeof(T));
				if (device_type == DeviceType.CPU)
				{
					return new TensorAccessor<T>(this);
				}
				return new TensorAccessor<T>(cpu());
			}

			public T item<T>() where T : unmanaged
			{
				if (NumberOfElements != 1)
				{
					throw new ArgumentException("Number of elements in the tensor must be 1");
				}
				return data<T>()[new long[1]];
			}

			internal void ValidateType(Type dotnetType)
			{
				switch (dtype)
				{
				case ScalarType.Byte:
					if (dotnetType != typeof(byte))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.Int8:
					if (dotnetType != typeof(sbyte))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.Int16:
					if (dotnetType != typeof(short))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.Int32:
					if (dotnetType != typeof(int))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.Int64:
					if (dotnetType != typeof(long))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.Bool:
					if (dotnetType != typeof(bool))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.BFloat16:
					throw new ArgumentException("No support for " + dtype.ToString() + " in TorchSharp");
				case ScalarType.Float16:
				case ScalarType.Float32:
					if (dotnetType != typeof(float))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.Float64:
					if (dotnetType != typeof(double))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.ComplexFloat32:
					if (dotnetType != typeof((float, float)))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case ScalarType.ComplexFloat64:
					if (dotnetType != typeof(Complex))
					{
						throw new ArgumentException(dotnetType.Name + " is not compatible with " + dtype);
					}
					break;
				case (ScalarType)8:
				case (ScalarType)12:
				case (ScalarType)13:
				case (ScalarType)14:
					break;
				}
			}

			public unsafe void WriteBytesToStream(Stream stream, int bufferSize = 1024)
			{
				_validate(0L);
				long num = NumberOfElements * ElementSize;
				IntPtr intPtr = NativeMethods.THSTensor_data(handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				byte[] array = new byte[bufferSize];
				while (num > 0)
				{
					int num2 = (int)Math.Min(num, bufferSize);
					new Span<byte>((void*)intPtr, num2).CopyTo(array);
					stream.Write(array, 0, num2);
					intPtr += num2;
					num -= num2;
				}
			}

			public unsafe void ReadBytesFromStream(Stream stream, int bufferSize = 1024)
			{
				long num = NumberOfElements * ElementSize;
				_validate(0L);
				IntPtr intPtr = NativeMethods.THSTensor_data(handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				byte[] array = new byte[bufferSize];
				while (num > 0)
				{
					int num2 = stream.Read(array, 0, (int)Math.Min(num, bufferSize));
					if (num2 == 0)
					{
						throw new EndOfStreamException();
					}
					Span<byte> destination = new Span<byte>((void*)intPtr, num2);
					array.AsSpan(0, num2).CopyTo(destination);
					intPtr += num2;
					num -= num2;
				}
			}

			private void _validate(long totalSize)
			{
				if (!is_contiguous())
				{
					throw new InvalidOperationException("Bytes() called on non-contiguous tensor.");
				}
				if (totalSize > int.MaxValue)
				{
					throw new ArgumentException("Span only supports up to int.MaxValue elements.");
				}
				if (device_type != DeviceType.CPU)
				{
					throw new InvalidOperationException("Reading data from non-CPU memory is not supported. Move or copy the tensor to the cpu before reading.");
				}
			}

			public double ReadCpuDouble(long i)
			{
				return TensorAccessor<double>.ReadItemAt(this, i);
			}

			public float ReadCpuSingle(long i)
			{
				return TensorAccessor<float>.ReadItemAt(this, i);
			}

			public int ReadCpuInt32(long i)
			{
				return TensorAccessor<int>.ReadItemAt(this, i);
			}

			public long ReadCpuInt64(long i)
			{
				return TensorAccessor<long>.ReadItemAt(this, i);
			}

			public byte ReadCpuByte(long i)
			{
				return TensorAccessor<byte>.ReadItemAt(this, i);
			}

			public sbyte ReadCpuSByte(long i)
			{
				return TensorAccessor<sbyte>.ReadItemAt(this, i);
			}

			public short ReadCpuInt16(long i)
			{
				return TensorAccessor<short>.ReadItemAt(this, i);
			}

			public bool ReadCpuBool(long i)
			{
				return TensorAccessor<bool>.ReadItemAt(this, i);
			}

			public T ReadCpuValue<T>(long i) where T : unmanaged
			{
				return TensorAccessor<T>.ReadItemAt(this, i);
			}

			public float ReadCpuFloat16(long i)
			{
				if (i >= NumberOfElements)
				{
					throw new IndexOutOfRangeException("The index is greater than the number of elements in the tensor");
				}
				return NativeMethods.THSTensor_data_idx_float16(handle, i);
			}

			public float ReadCpuBFloat16(long i)
			{
				if (i >= NumberOfElements)
				{
					throw new IndexOutOfRangeException("The index is greater than the number of elements in the tensor");
				}
				return NativeMethods.THSTensor_data_idx_bfloat16(handle, i);
			}

			public Scalar ToScalar()
			{
				IntPtr intPtr = NativeMethods.THSTensor_item(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Scalar(intPtr);
			}

			public Tensor fill_(Scalar value)
			{
				NativeMethods.THSTensor_fill_(Handle, value?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public void backward(IList<Tensor>? grad_tensors = null, bool retain_graph = false, bool create_graph = false, IList<Tensor>? inputs = null)
			{
				autograd.backward(new Tensor[1] { this }, grad_tensors, retain_graph, create_graph, inputs);
			}

			public static Tensor load(string location)
			{
				IntPtr intPtr = NativeMethods.THSTensor_load(location);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public void save(string location)
			{
				NativeMethods.THSTensor_save(Handle, location);
				CheckForErrors();
			}

			public Tensor requires_grad_(bool requires_grad = true)
			{
				this.requires_grad = requires_grad;
				return this;
			}

			public void retain_grad()
			{
				NativeMethods.THSTensor_retain_grad(Handle);
				CheckForErrors();
			}

			public Tensor with_requires_grad(bool requires_grad = true)
			{
				this.requires_grad = requires_grad;
				return this;
			}

			public bool is_cpu()
			{
				bool result = NativeMethods.THSTensor_is_cpu(Handle);
				CheckForErrors();
				return result;
			}

			public Tensor cpu()
			{
				IntPtr intPtr = NativeMethods.THSTensor_cpu(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor mps(bool non_blocking = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_to_device(Handle, 13, -1, copy: true, non_blocking);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cuda(Device? device = null, bool non_blocking = false)
			{
				if (device != null && device.type != DeviceType.CUDA)
				{
					throw new ArgumentException("Not a CUDA device.", "device");
				}
				InitializeDeviceType(DeviceType.CUDA);
				IntPtr intPtr = ((device == null) ? NativeMethods.THSTensor_cuda(Handle) : NativeMethods.THSTensor_to_device(Handle, 1, device_index, copy: false, non_blocking));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor to_type(ScalarType type, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_to_type(Handle, (sbyte)type, copy, non_blocking);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (disposeAfter)
				{
					Dispose();
				}
				return new Tensor(intPtr);
			}

			public Tensor type_as(Tensor tensor)
			{
				return to_type(tensor.dtype);
			}

			public Tensor set_(Tensor source)
			{
				NativeMethods.THSTensor_set_(Handle, source.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor to(DeviceType deviceType, int deviceIndex = -1, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
			{
				InitializeDeviceType(deviceType);
				IntPtr intPtr = NativeMethods.THSTensor_to_device(Handle, (int)deviceType, deviceIndex, copy, non_blocking);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (disposeAfter)
				{
					Dispose();
				}
				return new Tensor(intPtr);
			}

			public Tensor to(ScalarType type, Device device, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_to_type_and_device(Handle, (sbyte)type, (int)device.type, device.index, copy, non_blocking);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (disposeAfter)
				{
					Dispose();
				}
				return new Tensor(intPtr);
			}

			public Tensor to(ScalarType type, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
			{
				return to_type(type, copy, disposeAfter, non_blocking);
			}

			public Tensor to(string device, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
			{
				return to(new Device(device), copy, disposeAfter, non_blocking);
			}

			public Tensor to(Device device, bool copy = false, bool disposeAfter = false, bool non_blocking = false)
			{
				return to(device.type, device.index, copy, disposeAfter, non_blocking);
			}

			public Tensor to(Tensor other, bool non_blocking = false)
			{
				return to(other.dtype, other.device, non_blocking);
			}

			public Tensor type(Func<Tensor, Tensor> typeFunc)
			{
				return typeFunc(this);
			}

			public Tensor type(ScalarType dtype)
			{
				return to(dtype);
			}

			public long size(int dim)
			{
				long result = NativeMethods.THSTensor_size(Handle, dim);
				CheckForErrors();
				return result;
			}

			public long[] size()
			{
				using PinnedArray<long> pinnedArray = new PinnedArray<long>();
				NativeMethods.THSTensor_sizes(Handle, pinnedArray.CreateArray);
				CheckForErrors();
				return pinnedArray.Array;
			}

			public bool has_names()
			{
				bool result = NativeMethods.THSTensor_has_names(Handle);
				CheckForErrors();
				return result;
			}

			private static IntPtr MarshalDimensionString(string? s)
			{
				if (s != null)
				{
					return Marshal.StringToHGlobalAnsi(s);
				}
				return Marshal.StringToHGlobalAnsi("*");
			}

			public Tensor rename(IEnumerable<string?>? names)
			{
				if (names != null && names.Count() != ndim && !names.Contains<string>("..."))
				{
					throw new ArgumentException($"The number of dimension names ({names.Count()}) is different from the number of dimensions ({ndim}).");
				}
				IntPtr intPtr = IntPtr.Zero;
				if (names != null && names.Count() > 0)
				{
					IntPtr[] array = ExpandEllipsis(names);
					IntPtr zero = IntPtr.Zero;
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					zero = pinnedArray.CreateArray(array);
					intPtr = NativeMethods.THSTensor_rename(Handle, zero, (names != null) ? array.Length : 0);
				}
				else
				{
					intPtr = NativeMethods.THSTensor_rename(Handle, IntPtr.Zero, 0L);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor rename_(IEnumerable<string?>? names)
			{
				if (names != null && names.Count() != ndim && !names.Contains<string>("..."))
				{
					throw new ArgumentException($"The number of dimension names ({names.Count()}) is different from the number of dimensions ({ndim}).");
				}
				if (names != null && names.Count() > 0)
				{
					IntPtr[] array = ExpandEllipsis(names);
					IntPtr zero = IntPtr.Zero;
					using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
					zero = pinnedArray.CreateArray(array);
					NativeMethods.THSTensor_rename_(Handle, zero, (names != null) ? array.Length : 0);
				}
				else
				{
					NativeMethods.THSTensor_rename_(Handle, IntPtr.Zero, 0L);
				}
				CheckForErrors();
				_names = null;
				return this;
			}

			public Tensor refine_names(IEnumerable<string> names)
			{
				IntPtr[] array = ExpandEllipsis(names);
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = pinnedArray.CreateArray(array);
				IntPtr intPtr2 = NativeMethods.THSTensor_refine_names(Handle, intPtr, array.Length);
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr2);
			}

			private IntPtr[] ExpandEllipsis(IEnumerable<string?> names)
			{
				int num = names.Count();
				IntPtr[] array = new IntPtr[ndim];
				if (names.Contains<string>("..."))
				{
					int num2 = -1;
					foreach (string name in names)
					{
						num2++;
						if (name == "...")
						{
							break;
						}
						array[num2] = MarshalDimensionString(name);
					}
					if (num2 == num - 1)
					{
						int i = num2;
						if (has_names())
						{
							string[] array2 = this.names;
							for (; i < array.Length; i++)
							{
								array[i] = MarshalDimensionString(array2[i]);
							}
						}
						else
						{
							for (; i < array.Length; i++)
							{
								array[i] = IntPtr.Zero;
							}
						}
					}
					else
					{
						int num3 = num2;
						int num4 = (int)(ndim - num + 1);
						if (has_names())
						{
							string[] array3 = this.names;
							int num5 = 0;
							while (num5 < num4)
							{
								array[num3] = MarshalDimensionString(array3[num3]);
								num5++;
								num3++;
							}
						}
						else
						{
							int num6 = 0;
							while (num6 < num4)
							{
								array[num3] = IntPtr.Zero;
								num6++;
								num3++;
							}
						}
						foreach (string item in names.Skip(num2 + 1))
						{
							array[num3] = MarshalDimensionString(item);
							num3++;
						}
					}
				}
				else
				{
					int num7 = 0;
					foreach (string name2 in names)
					{
						array[num7] = MarshalDimensionString(name2);
						num7++;
					}
				}
				return array;
			}

			public Tensor refine_names(params string[] names)
			{
				return refine_names((IEnumerable<string>)names);
			}

			public Tensor vander(long N = -1L, bool increasing = false)
			{
				if (Dimensions != 1)
				{
					throw new InvalidOperationException("Input argument for 'vander()' must be 1-D.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_vander(Handle, (N == -1) ? size(0) : N, increasing);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public long[] stride()
			{
				using PinnedArray<long> pinnedArray = new PinnedArray<long>();
				NativeMethods.THSTensor_strides(Handle, pinnedArray.CreateArray);
				CheckForErrors();
				return pinnedArray.Array;
			}

			public long stride(int dim)
			{
				long result = NativeMethods.THSTensor_stride(Handle, dim);
				CheckForErrors();
				return result;
			}

			public unsafe Tensor as_strided(long[] size, long[] strides, long storageOffset = 0L)
			{
				fixed (long* ptr = size)
				{
					fixed (long* ptr2 = strides)
					{
						IntPtr intPtr = NativeMethods.THSTensor_as_strided(Handle, (IntPtr)ptr, size.Length, (IntPtr)ptr2, strides.Length, storageOffset);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public void backward()
			{
				NativeMethods.THSTensor_backward(Handle);
				CheckForErrors();
			}

			public Tensor to_dense()
			{
				IntPtr intPtr = NativeMethods.THSTensor_to_dense(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor clone()
			{
				IntPtr intPtr = NativeMethods.THSTensor_clone(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor copy_(Tensor source, bool nonBlocking = false)
			{
				NativeMethods.THSTensor_copy_(Handle, source.Handle, nonBlocking);
				CheckForErrors();
				return this;
			}

			public bool is_contiguous()
			{
				int num = NativeMethods.THSTensor_is_contiguous(Handle);
				CheckForErrors();
				return num != 0;
			}

			public Tensor contiguous()
			{
				IntPtr intPtr = NativeMethods.THSTensor_contiguous(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public bool is_pinned()
			{
				long num = NativeMethods.THSTensor_is_pinned(Handle);
				CheckForErrors();
				return num != 0;
			}

			public Tensor pin_memory()
			{
				IntPtr intPtr = NativeMethods.THSTensor_pin_memory(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			internal void EncodeIndices(TensorIndex[] indices, out long[] arrKindAndStarts, out long[]? arrStops, out long[]? arrSteps, out IntPtr[]? arrTensors)
			{
				bool flag = false;
				bool flag2 = false;
				bool flag3 = false;
				int num = indices.Length;
				for (int i = 0; i < indices.Length; i++)
				{
					TensorIndex tensorIndex = indices[i];
					if (tensorIndex.kind == TensorIndex.Kind.Slice && tensorIndex.stopIndex.HasValue)
					{
						flag = true;
					}
					if (tensorIndex.kind == TensorIndex.Kind.Slice && tensorIndex.step.HasValue)
					{
						flag2 = true;
					}
					if (tensorIndex.kind == TensorIndex.Kind.Tensor && (object)tensorIndex.tensor != null)
					{
						flag3 = true;
					}
				}
				arrStops = (flag ? new long[num] : null);
				arrSteps = (flag2 ? new long[num] : null);
				arrTensors = (flag3 ? new IntPtr[num] : null);
				arrKindAndStarts = new long[num];
				for (int j = 0; j < indices.Length; j++)
				{
					TensorIndex tensorIndex2 = indices[j];
					arrKindAndStarts[j] = ((tensorIndex2.kind == TensorIndex.Kind.Null) ? long.MinValue : ((tensorIndex2.kind == TensorIndex.Kind.Bool && tensorIndex2.startIndexOrBoolOrSingle == 0) ? (-9223372036854775807L) : ((tensorIndex2.kind == TensorIndex.Kind.Bool && tensorIndex2.startIndexOrBoolOrSingle != 0) ? (-9223372036854775806L) : ((tensorIndex2.kind == TensorIndex.Kind.Ellipsis) ? (-9223372036854775805L) : ((tensorIndex2.kind == TensorIndex.Kind.None) ? (-9223372036854775804L) : ((tensorIndex2.kind == TensorIndex.Kind.Tensor) ? (-9223372036854775803L) : ((tensorIndex2.kind == TensorIndex.Kind.Slice && !tensorIndex2.startIndexOrBoolOrSingle.HasValue) ? (-9223372036854775802L) : ((tensorIndex2.kind == TensorIndex.Kind.Single) ? tensorIndex2.startIndexOrBoolOrSingle.GetValueOrDefault() : (tensorIndex2.startIndexOrBoolOrSingle.GetValueOrDefault() + -4611686018427387904L)))))))));
					if (arrStops != null && tensorIndex2.kind == TensorIndex.Kind.Slice)
					{
						arrStops[j] = (tensorIndex2.stopIndex.HasValue ? tensorIndex2.stopIndex.Value : long.MinValue);
					}
					if (arrSteps != null && tensorIndex2.kind == TensorIndex.Kind.Slice)
					{
						arrSteps[j] = (tensorIndex2.step.HasValue ? tensorIndex2.step.Value : long.MinValue);
					}
					if (arrTensors != null && tensorIndex2.kind == TensorIndex.Kind.Tensor)
					{
						arrTensors[j] = (((object)tensorIndex2.tensor == null) ? IntPtr.Zero : tensorIndex2.tensor.Handle);
					}
				}
			}

			public unsafe Tensor index(params TensorIndex[] indices)
			{
				EncodeIndices(indices, out long[] arrKindAndStarts, out long[] arrStops, out long[] arrSteps, out IntPtr[] arrTensors);
				fixed (long* ptr = arrKindAndStarts)
				{
					fixed (long* ptr2 = arrStops)
					{
						fixed (long* ptr3 = arrSteps)
						{
							fixed (IntPtr* ptr4 = arrTensors)
							{
								IntPtr intPtr = NativeMethods.THSTensor_index(Handle, (IntPtr)ptr, (IntPtr)ptr2, (IntPtr)ptr3, (IntPtr)ptr4, indices.Length);
								if (intPtr == IntPtr.Zero)
								{
									CheckForErrors();
								}
								GC.KeepAlive(indices);
								return new Tensor(intPtr);
							}
						}
					}
				}
			}

			public Tensor index(params Tensor[] indices)
			{
				return index(indices.Select((Tensor t) => TensorIndex.Tensor(t)).ToArray());
			}

			public unsafe Tensor index_put_(Tensor value, params TensorIndex[] indices)
			{
				EncodeIndices(indices, out long[] arrKindAndStarts, out long[] arrStops, out long[] arrSteps, out IntPtr[] arrTensors);
				fixed (long* ptr = arrKindAndStarts)
				{
					fixed (long* ptr2 = arrStops)
					{
						fixed (long* ptr3 = arrSteps)
						{
							fixed (IntPtr* ptr4 = arrTensors)
							{
								NativeMethods.THSTensor_index_put_(Handle, (IntPtr)ptr, (IntPtr)ptr2, (IntPtr)ptr3, (IntPtr)ptr4, indices.Length, value.Handle, accumulate: false);
								CheckForErrors();
								GC.KeepAlive(indices);
								GC.KeepAlive(value);
								return this;
							}
						}
					}
				}
			}

			public unsafe Tensor index_put_(Tensor value, TensorIndex[] indices, bool accumulate = false)
			{
				EncodeIndices(indices, out long[] arrKindAndStarts, out long[] arrStops, out long[] arrSteps, out IntPtr[] arrTensors);
				if (accumulate && arrTensors == null)
				{
					throw new Exception("Invalid 'indices' parameter. Must be an array of TensorIndex objects containing tensors with indices that match the shape of the tensor to update");
				}
				fixed (long* ptr = arrKindAndStarts)
				{
					fixed (long* ptr2 = arrStops)
					{
						fixed (long* ptr3 = arrSteps)
						{
							fixed (IntPtr* ptr4 = arrTensors)
							{
								NativeMethods.THSTensor_index_put_(Handle, (IntPtr)ptr, (IntPtr)ptr2, (IntPtr)ptr3, (IntPtr)ptr4, indices.Length, value.Handle, accumulate);
								CheckForErrors();
								GC.KeepAlive(indices);
								GC.KeepAlive(value);
								return this;
							}
						}
					}
				}
			}

			public Tensor index_put_(Tensor value, params Tensor[] indices)
			{
				return index_put_(value, indices.Select((Tensor t) => TensorIndex.Tensor(t)).ToArray());
			}

			public Tensor index_put_(Tensor value, Tensor[] indices, bool accumulate = false)
			{
				return index_put_(value, indices.Select((Tensor t) => TensorIndex.Tensor(t)).ToArray(), accumulate);
			}

			public unsafe Tensor index_put_(Scalar value, params TensorIndex[] indices)
			{
				EncodeIndices(indices, out long[] arrKindAndStarts, out long[] arrStops, out long[] arrSteps, out IntPtr[] arrTensors);
				fixed (long* ptr = arrKindAndStarts)
				{
					fixed (long* ptr2 = arrStops)
					{
						fixed (long* ptr3 = arrSteps)
						{
							fixed (IntPtr* ptr4 = arrTensors)
							{
								NativeMethods.THSTensor_index_put_scalar_(Handle, (IntPtr)ptr, (IntPtr)ptr2, (IntPtr)ptr3, (IntPtr)ptr4, indices.Length, value.Handle);
								CheckForErrors();
								GC.KeepAlive(indices);
								GC.KeepAlive(value);
								return this;
							}
						}
					}
				}
			}

			public Tensor index_put_(Scalar value, params Tensor[] indices)
			{
				return index_put_(value, indices.Select((Tensor t) => TensorIndex.Tensor(t)).ToArray());
			}

			public Tensor index_select(long dim, Tensor index)
			{
				IntPtr intPtr = NativeMethods.THSTensor_index_select(Handle, dim, index.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor select(long dim, long index)
			{
				IntPtr intPtr = NativeMethods.THSTensor_select(Handle, dim, index);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor take(Tensor index)
			{
				IntPtr intPtr = NativeMethods.THSTensor_take(Handle, index.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor argwhere()
			{
				IntPtr intPtr = NativeMethods.THSTensor_argwhere(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor take_along_dim(Tensor indices)
			{
				IntPtr intPtr = NativeMethods.THSTensor_take_along_dim_dflt(Handle, indices.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor take_along_dim(IEnumerable<long> indices)
			{
				return take_along_dim(tensor(indices.ToArray()));
			}

			public Tensor take_along_dim(Tensor indices, long dim)
			{
				IntPtr intPtr = NativeMethods.THSTensor_take_along_dim(Handle, indices.Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor take_along_dim(IEnumerable<long> indices, long dim)
			{
				return take_along_dim(tensor(indices.ToArray()), dim);
			}

			public Tensor index_add(long dim, Tensor index, Tensor source, Scalar alpha)
			{
				if (index.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Element type of 'index' must be 'Int64'");
				}
				IntPtr intPtr = NativeMethods.THSTensor_index_add(Handle, dim, index.Handle, source.Handle, alpha.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor index_add_(long dim, Tensor index, Tensor source, Scalar alpha)
			{
				if (index.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Element type of 'index' must be 'Int64'");
				}
				NativeMethods.THSTensor_index_add_(Handle, dim, index.Handle, source.Handle, alpha.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor index_copy(long dim, Tensor index, Tensor source)
			{
				if (index.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Element type of 'index' must be 'Int64'");
				}
				IntPtr intPtr = NativeMethods.THSTensor_index_copy(Handle, dim, index.Handle, source.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor index_copy_(long dim, Tensor index, Tensor source)
			{
				if (index.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Element type of 'index' must be 'Int64'");
				}
				NativeMethods.THSTensor_index_copy_(Handle, dim, index.Handle, source.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor index_fill(long dim, Tensor index, Scalar value)
			{
				if (index.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Element type of 'index' must be 'Int64'");
				}
				IntPtr intPtr = NativeMethods.THSTensor_index_fill(Handle, dim, index.Handle, value.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor index_fill_(long dim, Tensor index, Scalar value)
			{
				if (index.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Element type of 'index' must be 'Int64'");
				}
				NativeMethods.THSTensor_index_fill_(Handle, dim, index.Handle, value.Handle);
				CheckForErrors();
				return this;
			}

			public unsafe Tensor reshape(params long[] shape)
			{
				fixed (long* ptr = shape)
				{
					IntPtr intPtr = NativeMethods.THSTensor_reshape(Handle, (IntPtr)ptr, shape.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor flatten(long start_dim = 0L, long end_dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_flatten(Handle, start_dim, end_dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor flatten(IList<string?> dims, string out_dim)
			{
				if (dims.Count == 0)
				{
					throw new ArgumentException($"The number of input dimension names ({dims.Count}) is zero.");
				}
				if (dims.Count > ndim)
				{
					throw new ArgumentException($"The number of input dimension names ({dims.Count}) is larger than the number of dimensions ({ndim}).");
				}
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				List<IntPtr> list = dims.Select((string s) => Marshal.StringToHGlobalAnsi(s)).ToList();
				list.Add(Marshal.StringToHGlobalAnsi(out_dim));
				IntPtr intPtr = pinnedArray.CreateArray(list.ToArray());
				IntPtr intPtr2 = NativeMethods.THSTensor_flatten_names(Handle, intPtr, list.Count);
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr2);
			}

			public unsafe Tensor unflatten(long dim, params long[] sizes)
			{
				if (dim < 0 || dim >= ndim)
				{
					throw new ArgumentException($"Invalid 'dim' argument: {dim}.");
				}
				if (sizes.Length == 0)
				{
					throw new ArgumentException("The number of output sizes is zero.");
				}
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_unflatten(Handle, dim, (IntPtr)ptr, sizes.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe Tensor unflatten(string dim, params (string, long)[] sizes)
			{
				if (sizes.Length == 0)
				{
					throw new ArgumentException("The number of output sizes is zero.");
				}
				List<string> list = sizes.Select(((string, long) s) => s.Item1).ToList();
				long[] array = sizes.Select(((string, long) s) => s.Item2).ToArray();
				list.Insert(0, dim);
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = pinnedArray.CreateArray(list.Select((string s) => Marshal.StringToHGlobalAnsi(s)).ToArray());
				fixed (long* ptr = array)
				{
					IntPtr intPtr2 = NativeMethods.THSTensor_unflatten_names(Handle, intPtr, (IntPtr)ptr, list.Count);
					if (intPtr2 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr2);
				}
			}

			public Tensor align_to(IEnumerable<string> names)
			{
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = pinnedArray.CreateArray(names.Select((string s) => Marshal.StringToHGlobalAnsi(s)).ToArray());
				IntPtr intPtr2 = NativeMethods.THSTensor_align_to(Handle, intPtr, names.Count());
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr2);
			}

			public Tensor align_to(params string[] names)
			{
				return align_to((IEnumerable<string>)names);
			}

			public Tensor align_as(Tensor other)
			{
				return align_to(other.names);
			}

			public (Tensor output, Tensor? inverse_indices, Tensor? counts) unique(bool sorted = true, bool return_inverse = false, bool return_counts = false, int? dim = null)
			{
				IntPtr zero = IntPtr.Zero;
				zero = (dim.HasValue ? NativeMethods.THSTensor_unique_dim(Handle, dim.Value, sorted, return_inverse, return_counts, out var inverse_indices, out var counts) : NativeMethods.THSTensor_unique(Handle, sorted, return_inverse, return_counts, out inverse_indices, out counts));
				if (zero == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (output: new Tensor(zero), inverse_indices: (inverse_indices != IntPtr.Zero) ? new Tensor(inverse_indices) : null, counts: (counts != IntPtr.Zero) ? new Tensor(counts) : null);
			}

			public (Tensor output, Tensor? inverse_indices, Tensor? counts) unique_consecutive(bool return_inverse = false, bool return_counts = false, int? dim = null)
			{
				IntPtr inverse_indices;
				IntPtr counts;
				IntPtr intPtr = ((!dim.HasValue) ? NativeMethods.THSTensor_unique_consecutive(Handle, return_inverse, return_counts, out inverse_indices, out counts) : NativeMethods.THSTensor_unique_dim_consecutive(Handle, dim.Value, return_inverse, return_counts, out inverse_indices, out counts));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (output: new Tensor(intPtr), inverse_indices: (inverse_indices != IntPtr.Zero) ? new Tensor(inverse_indices) : null, counts: (counts != IntPtr.Zero) ? new Tensor(counts) : null);
			}

			public Tensor unflatten(long dim, Size sizes)
			{
				return unflatten(dim, sizes.Shape);
			}

			public Tensor squeeze(long? dim = null)
			{
				IntPtr intPtr = (dim.HasValue ? NativeMethods.THSTensor_squeeze(Handle, dim.Value) : NativeMethods.THSTensor_squeeze_no_dim(Handle));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor squeeze_(long? dim = null)
			{
				if (dim.HasValue)
				{
					NativeMethods.THSTensor_squeeze_(Handle, dim.Value);
				}
				else
				{
					NativeMethods.THSTensor_squeeze_no_dim_(Handle);
				}
				CheckForErrors();
				return this;
			}

			public Tensor t()
			{
				IntPtr intPtr = NativeMethods.THSTensor_t(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor transpose(long dim0, long dim1)
			{
				IntPtr intPtr = NativeMethods.THSTensor_transpose(Handle, dim0, dim1);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor transpose_(long dim0, long dim1)
			{
				NativeMethods.THSTensor_transpose_(Handle, dim0, dim1);
				CheckForErrors();
				return this;
			}

			public Tensor threshold(Scalar threshold, Scalar value)
			{
				IntPtr intPtr = NativeMethods.THSTensor_threshold(Handle, threshold.Handle, value.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor threshold_(Scalar threshold, Scalar value)
			{
				NativeMethods.THSTensor_threshold_(Handle, threshold.Handle, value.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor adjoint()
			{
				IntPtr intPtr = NativeMethods.THSTensor_adjoint(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor tril(long diagonal = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_tril(Handle, diagonal, inplace: false);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor tril_(long diagonal = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_tril(Handle, diagonal, inplace: true);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor triu(long diagonal = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_triu(Handle, diagonal, inplace: false);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor triu_(long diagonal = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_triu(Handle, diagonal, inplace: true);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor swapdims(long dim0, long dim1)
			{
				return transpose(dim0, dim1);
			}

			public Tensor swapaxes(long dim0, long dim1)
			{
				return transpose(dim0, dim1);
			}

			public unsafe Tensor view(params long[] shape)
			{
				fixed (long* ptr = shape)
				{
					IntPtr intPtr = NativeMethods.THSTensor_view(Handle, (IntPtr)ptr, shape.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor view_as(Tensor other)
			{
				return view(other.shape);
			}

			public Tensor view_as_complex()
			{
				IntPtr intPtr = NativeMethods.THSTensor_view_as_complex(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor view_as_real()
			{
				IntPtr intPtr = NativeMethods.THSTensor_view_as_real(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor all()
			{
				IntPtr intPtr = NativeMethods.THSTensor_all(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor all(long dim, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_all_along_dimension(Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor amax(long[] dims, bool keepdim = false, Tensor? @out = null)
			{
				return amax((ReadOnlySpan<long>)dims, keepdim, @out);
			}

			public Tensor amax(params long[] dims)
			{
				return amax((ReadOnlySpan<long>)dims, keepdim: false, (Tensor?)null);
			}

			public unsafe Tensor amax(ReadOnlySpan<long> dims, bool keepdim = false, Tensor? @out = null)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSTensor_amax(Handle, (IntPtr)ptr, dims.Length, keepdim) : NativeMethods.THSTensor_amax_out(Handle, (IntPtr)ptr, dims.Length, keepdim, @out.Handle));
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe Tensor amin(ReadOnlySpan<long> dims, bool keepdim = false, Tensor? @out = null)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = (((object)@out == null) ? NativeMethods.THSTensor_amin(Handle, (IntPtr)ptr, dims.Length, keepdim) : NativeMethods.THSTensor_amin_out(Handle, (IntPtr)ptr, dims.Length, keepdim, @out.Handle));
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor amin(long[] dims, bool keepdim = false, Tensor? @out = null)
			{
				return amin((ReadOnlySpan<long>)dims, keepdim, @out);
			}

			public Tensor amin(params long[] dims)
			{
				return amin((ReadOnlySpan<long>)dims, keepdim: false, (Tensor?)null);
			}

			public (Tensor min, Tensor max) aminmax(long? dim = null, bool keepdim = false)
			{
				IntPtr intPtr2;
				IntPtr intPtr = NativeMethods.THSTensor_aminmax(Handle, (!dim.HasValue) ? (-1) : dim.Value, keepdim, out intPtr2);
				if (intPtr == IntPtr.Zero || intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (min: new Tensor(intPtr), max: new Tensor(intPtr2));
			}

			public Tensor any()
			{
				IntPtr intPtr = NativeMethods.THSTensor_any(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor any(long dim, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_any_along_dimension(Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor argmax()
			{
				IntPtr intPtr = NativeMethods.THSTensor_argmax(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor argmax(long dim, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_argmax_along_dimension(Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor argmin()
			{
				IntPtr intPtr = NativeMethods.THSTensor_argmin(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor argmin(long dim, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_argmin_along_dimension(Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor argsort(long dim = -1L, bool descending = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_argsort(Handle, dim, descending);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor deg2rad()
			{
				IntPtr intPtr = NativeMethods.THSTensor_deg2rad(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor rad2deg()
			{
				IntPtr intPtr = NativeMethods.THSTensor_rad2deg(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor copysign(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_copysign(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor count_nonzero(long[]? dims = null)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSTensor_count_nonzero(Handle, (IntPtr)ptr, (dims != null) ? dims.Length : 0);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor cov(long correction = 1L, Tensor? fweights = null, Tensor? aweights = null)
			{
				IntPtr fweights2 = fweights?.Handle ?? IntPtr.Zero;
				IntPtr aweights2 = aweights?.Handle ?? IntPtr.Zero;
				IntPtr intPtr = NativeMethods.THSTensor_cov(Handle, correction, fweights2, aweights2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor corrcoef()
			{
				IntPtr intPtr = NativeMethods.THSTensor_corrcoef(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor tile(long[] reps)
			{
				fixed (long* ptr = reps)
				{
					IntPtr intPtr = NativeMethods.THSTensor_tile(Handle, (IntPtr)ptr, reps.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor digamma()
			{
				IntPtr intPtr = NativeMethods.THSTensor_digamma(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor digamma_()
			{
				NativeMethods.THSTensor_digamma_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor lgamma()
			{
				IntPtr intPtr = NativeMethods.THSTensor_lgamma(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor lgamma_()
			{
				NativeMethods.THSTensor_lgamma_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor mvlgamma(long p)
			{
				IntPtr intPtr = NativeMethods.THSTensor_mvlgamma(Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor mvlgamma_(long p)
			{
				NativeMethods.THSTensor_mvlgamma_(Handle, p);
				CheckForErrors();
				return this;
			}

			public Tensor polygamma(long p)
			{
				IntPtr intPtr = NativeMethods.THSTensor_polygamma(Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor polygamma_(long p)
			{
				NativeMethods.THSTensor_polygamma_(Handle, p);
				CheckForErrors();
				return this;
			}

			public Tensor positive()
			{
				if (dtype == ScalarType.Bool)
				{
					throw new ArgumentException("Boolean tensor");
				}
				IntPtr intPtr = NativeMethods.THSTensor_positive(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor softmax(long dim, ScalarType? dtype = null)
			{
				return special.softmax(this, dim, dtype);
			}

			public Tensor softplus(double beta = 1.0, double threshold = 20.0)
			{
				return softplus1(beta, threshold);
			}

			private Tensor softplus1(Scalar beta, Scalar threshold)
			{
				IntPtr intPtr = NativeMethods.THSTensor_softplus(Handle, beta.Handle, threshold.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ravel()
			{
				IntPtr intPtr = NativeMethods.THSTensor_ravel(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor relu()
			{
				IntPtr intPtr = NativeMethods.THSTensor_relu(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor relu_()
			{
				NativeMethods.THSTensor_relu_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor relu6()
			{
				IntPtr intPtr = NativeMethods.THSTensor_relu6(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor relu6_()
			{
				NativeMethods.THSTensor_relu6_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor rrelu(double lower = 0.125, double upper = 1.0 / 3.0)
			{
				IntPtr intPtr = NativeMethods.THSTensor_rrelu(Handle, lower, upper);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor rrelu_(double lower = 0.125, double upper = 1.0 / 3.0)
			{
				NativeMethods.THSTensor_rrelu_(Handle, lower, upper);
				CheckForErrors();
				return this;
			}

			public Tensor celu()
			{
				return celu(1.0);
			}

			public Tensor celu_()
			{
				return celu_(1.0);
			}

			public Tensor celu(Scalar alpha)
			{
				IntPtr intPtr = NativeMethods.THSTensor_celu(Handle, alpha.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor celu_(Scalar alpha)
			{
				NativeMethods.THSTensor_celu_(Handle, alpha.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor elu(double alpha = 1.0)
			{
				return elu(alpha, 1.0, 1.0);
			}

			public Tensor elu_(double alpha = 1.0)
			{
				return elu(alpha, 1.0, 1.0);
			}

			public Tensor elu(Scalar alpha, Scalar scale, Scalar input_scale)
			{
				IntPtr intPtr = NativeMethods.THSTensor_elu(Handle, alpha.Handle, scale.Handle, input_scale.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor elu_(Scalar alpha, Scalar scale, Scalar input_scale)
			{
				NativeMethods.THSTensor_elu_(Handle, alpha.Handle, scale.Handle, input_scale.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor gelu()
			{
				IntPtr intPtr = NativeMethods.THSTensor_gelu(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor gelu_()
			{
				IntPtr intPtr = NativeMethods.THSTensor_gelu_(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor glu(long dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_glu(Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor hardsigmoid()
			{
				IntPtr intPtr = NativeMethods.THSTensor_hardsigmoid(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor hardsigmoid_()
			{
				NativeMethods.THSTensor_hardsigmoid_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor hardswish()
			{
				IntPtr intPtr = NativeMethods.THSTensor_hardswish(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor hardswish_()
			{
				NativeMethods.THSTensor_hardswish_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor hardtanh(Scalar min, Scalar max)
			{
				NativeMethods.THSTensor_hardtanh(Handle, min.Handle, max.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor hardtanh_(Scalar min, Scalar max)
			{
				NativeMethods.THSTensor_hardtanh_(Handle, min.Handle, max.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor heaviside(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_heaviside(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor igamma(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_igamma(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor igammac(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_igammac(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor i0()
			{
				IntPtr intPtr = NativeMethods.THSTensor_i0(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isclose(Tensor other, double rtol = 1E-05, double atol = 1E-08, bool nanEqual = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_isclose(Handle, other.Handle, rtol, atol, nanEqual);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isin(Tensor test_elements, bool assumeUnique = false, bool invert = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_isin(Handle, test_elements.Handle, assumeUnique, invert);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isinf()
			{
				IntPtr intPtr = NativeMethods.THSTensor_isinf(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isfinite()
			{
				IntPtr intPtr = NativeMethods.THSTensor_isfinite(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isposinf()
			{
				IntPtr intPtr = NativeMethods.THSTensor_isposinf(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isneginf()
			{
				IntPtr intPtr = NativeMethods.THSTensor_isneginf(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isnan()
			{
				IntPtr intPtr = NativeMethods.THSTensor_isnan(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor isreal()
			{
				IntPtr intPtr = NativeMethods.THSTensor_isreal(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor leaky_relu(Scalar negative_slope)
			{
				IntPtr intPtr = NativeMethods.THSTensor_leaky_relu(Handle, negative_slope.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor leaky_relu_(Scalar negative_slope)
			{
				NativeMethods.THSTensor_leaky_relu_(Handle, negative_slope.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor selu()
			{
				IntPtr intPtr = NativeMethods.THSTensor_selu(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor selu_()
			{
				NativeMethods.THSTensor_selu_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor silu()
			{
				IntPtr intPtr = NativeMethods.THSTensor_silu(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor silu_()
			{
				NativeMethods.THSTensor_silu_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor log_sigmoid()
			{
				IntPtr intPtr = NativeMethods.THSTensor_log_sigmoid(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor lerp(Tensor end, Tensor weight)
			{
				IntPtr intPtr = NativeMethods.THSTensor_lerp(Handle, end.Handle, weight.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor lerp_(Tensor end, Tensor weight)
			{
				NativeMethods.THSTensor_lerp_(Handle, end.Handle, weight.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor baddbmm(Tensor batch1, Tensor batch2, float beta = 1f, float alpha = 1f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_baddbmm(Handle, batch1.Handle, batch2.Handle, beta, alpha);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bmm(Tensor batch2)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bmm(Handle, batch2.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bucketize(Tensor boundaries, bool outInt32 = false, bool right = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bucketize(Handle, boundaries.Handle, outInt32, right);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bincount(Tensor? weights, long minlength = 0L)
			{
				IntPtr weights2 = weights?.Handle ?? IntPtr.Zero;
				IntPtr intPtr = NativeMethods.THSTensor_bincount(Handle, weights2, minlength);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor @bool()
			{
				return to_type(ScalarType.Bool);
			}

			public Tensor @byte()
			{
				return to_type(ScalarType.Byte);
			}

			public Tensor @char()
			{
				return to_type(ScalarType.Int8);
			}

			public Tensor @short()
			{
				return to_type(ScalarType.Int16);
			}

			public Tensor @int()
			{
				return to_type(ScalarType.Int32);
			}

			public Tensor @long()
			{
				return to_type(ScalarType.Int64);
			}

			public Tensor half()
			{
				return to_type(ScalarType.Float16);
			}

			public Tensor bfloat16()
			{
				return to_type(ScalarType.BFloat16);
			}

			public Tensor @float()
			{
				return to_type(ScalarType.Float32);
			}

			public Tensor @double()
			{
				return to_type(ScalarType.Float64);
			}

			public Tensor cfloat()
			{
				return to_type(ScalarType.ComplexFloat32);
			}

			public Tensor cdouble()
			{
				return to_type(ScalarType.ComplexFloat64);
			}

			public Tensor channel_shuffle(long groups)
			{
				IntPtr intPtr = NativeMethods.THSTensor_channel_shuffle(Handle, groups);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor clamp(Scalar? min = null, Scalar? max = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_clamp(Handle, min?.Handle ?? IntPtr.Zero, max?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor clamp(Tensor? min = null, Tensor? max = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_clamp_tensor(Handle, min?.Handle ?? IntPtr.Zero, max?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor clip(Scalar? min = null, Scalar? max = null)
			{
				return clamp(min, max);
			}

			public Tensor clamp_(Scalar? min = null, Scalar? max = null)
			{
				NativeMethods.THSTensor_clamp_(Handle, min?.Handle ?? IntPtr.Zero, max?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor clamp_(Tensor? min = null, Tensor? max = null)
			{
				NativeMethods.THSTensor_clamp_tensor_(Handle, min?.Handle ?? IntPtr.Zero, max?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor clamp_max(Scalar max)
			{
				IntPtr intPtr = NativeMethods.THSTensor_clamp_max(Handle, max.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor clamp_max_(Scalar max)
			{
				NativeMethods.THSTensor_clamp_max_(Handle, max.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor clamp_min(Scalar min)
			{
				IntPtr intPtr = NativeMethods.THSTensor_clamp_min(Handle, min.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor clamp_min_(Scalar min)
			{
				NativeMethods.THSTensor_clamp_min_(Handle, min.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor diff(long n = 1L, long dim = -1L, Tensor? prepend = null, Tensor? append = null)
			{
				if (n != 1)
				{
					throw new NotImplementedException("Tensor.diff with n != 1");
				}
				IntPtr intPtr = NativeMethods.THSTensor_diff(Handle, n, dim, prepend?.Handle ?? IntPtr.Zero, append?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor diag(long diagonal = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_diag(Handle, diagonal);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor trace()
			{
				if (ndim != 2)
				{
					throw new ArgumentException($"Expected a matrix, but got tensor with ndim == {ndim}");
				}
				IntPtr intPtr = NativeMethods.THSTensor_trace(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor diag_embed(long offset = 0L, long dim1 = -2L, long dim2 = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_diag_embed(Handle, offset, dim1, dim2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor diagflat(long offset = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_diagflat(Handle, offset);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor diagonal(long offset = 0L, long dim1 = 0L, long dim2 = 1L)
			{
				if (dim1 == dim2)
				{
					throw new ArgumentException($"Diagonal dimensions cannot be identical {dim1}, {dim2}");
				}
				IntPtr intPtr = NativeMethods.THSTensor_diagonal(Handle, offset, dim1, dim2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor erf()
			{
				IntPtr intPtr = NativeMethods.THSTensor_erf(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor erf_()
			{
				NativeMethods.THSTensor_erf_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor erfc()
			{
				IntPtr intPtr = NativeMethods.THSTensor_erfc(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor erfc_()
			{
				NativeMethods.THSTensor_erfc_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor erfinv()
			{
				IntPtr intPtr = NativeMethods.THSTensor_erfinv(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor erfinv_()
			{
				NativeMethods.THSTensor_erfinv_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor eq(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				IntPtr intPtr = NativeMethods.THSTensor_eq(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor equal(Tensor target)
			{
				return eq(target);
			}

			public Tensor eq_(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				NativeMethods.THSTensor_eq_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor eq(Scalar target)
			{
				if (target == null)
				{
					return false;
				}
				IntPtr intPtr = NativeMethods.THSTensor_eq_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor eq_(Scalar target)
			{
				if (target == null)
				{
					return false;
				}
				NativeMethods.THSTensor_eq_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public bool Equals(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				bool result = NativeMethods.THSTensor_equal(Handle, target.Handle);
				CheckForErrors();
				return result;
			}

			public bool allclose(Tensor target, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)
			{
				if ((object)target == null)
				{
					return false;
				}
				bool result = NativeMethods.THSTensor_allclose(Handle, target.Handle, rtol, atol, equal_nan);
				CheckForErrors();
				return result;
			}

			public Tensor ge(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				IntPtr intPtr = NativeMethods.THSTensor_ge(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor greater_equal(Tensor target)
			{
				return ge(target);
			}

			public Tensor ge_(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				NativeMethods.THSTensor_ge_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor ge(Scalar target)
			{
				if (target == null)
				{
					return false;
				}
				IntPtr intPtr = NativeMethods.THSTensor_ge_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ge_(Scalar target)
			{
				if (target == null)
				{
					return false;
				}
				NativeMethods.THSTensor_ge_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor gt(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				IntPtr intPtr = NativeMethods.THSTensor_gt(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor greater(Tensor target)
			{
				return gt(target);
			}

			public Tensor gt_(Tensor target)
			{
				if ((object)target == null)
				{
					return false;
				}
				NativeMethods.THSTensor_gt_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor gt(Scalar target)
			{
				if (target == null)
				{
					return false;
				}
				IntPtr intPtr = NativeMethods.THSTensor_gt_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor gt_(Scalar target)
			{
				if (target == null)
				{
					return false;
				}
				NativeMethods.THSTensor_gt_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor kron(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_kron(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor lcm(Tensor other)
			{
				if (!torch.is_integral(dtype) || !torch.is_integral(other.dtype))
				{
					throw new ArgumentException("Arguments to 'lcm' must have integer element types.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_lcm(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor lcm_(Tensor other)
			{
				if (!torch.is_integral(dtype) || !torch.is_integral(other.dtype))
				{
					throw new ArgumentException("Arguments to 'lcm' must have integer element types.");
				}
				NativeMethods.THSTensor_lcm_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor ldexp(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ldexp(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ldexp_(Tensor other)
			{
				NativeMethods.THSTensor_ldexp_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor le(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_le(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor less_equal(Tensor target)
			{
				return le(target);
			}

			public Tensor le_(Tensor target)
			{
				NativeMethods.THSTensor_le_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor less_equal_(Tensor target)
			{
				return le_(target);
			}

			public Tensor le(Scalar target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_le_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor le_(Scalar target)
			{
				NativeMethods.THSTensor_le_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor lt(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_lt(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor less(Tensor target)
			{
				return lt(target);
			}

			public Tensor lt_(Tensor target)
			{
				NativeMethods.THSTensor_lt_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor lt(Scalar target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_lt_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor lt_(Scalar target)
			{
				NativeMethods.THSTensor_lt_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor masked_fill(Tensor mask, Scalar value)
			{
				IntPtr intPtr = NativeMethods.THSTensor_masked_fill(Handle, mask.Handle, value.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor masked_fill_(Tensor mask, Scalar value)
			{
				NativeMethods.THSTensor_masked_fill_(Handle, mask.Handle, value.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor masked_scatter(Tensor mask, Tensor value)
			{
				IntPtr intPtr = NativeMethods.THSTensor_masked_scatter(Handle, mask.Handle, value.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor masked_scatter_(Tensor mask, Tensor value)
			{
				NativeMethods.THSTensor_masked_scatter_(Handle, mask.Handle, value.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor masked_select(Tensor mask)
			{
				if (mask.dtype != ScalarType.Bool)
				{
					throw new ArgumentException("The mask tensor must be Boolean.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_masked_select(Handle, mask.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor values, Tensor indexes) topk(int k, int dim = -1, bool largest = true, bool sorted = true)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_topk(Handle, pinnedArray.CreateArray, k, dim, largest, sorted);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return (values: new Tensor(array[0]), indexes: new Tensor(array[1]));
			}

			public Tensor[] unbind(long dimension = 0L)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_unbind(Handle, pinnedArray.CreateArray, dimension);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor unfold(long dimension, long size, long step)
			{
				IntPtr intPtr = NativeMethods.THSTensor_unfold(Handle, dimension, size, step);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor[] split(long size, int dim = 0)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_split_with_size(Handle, pinnedArray.CreateArray, size, dim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public unsafe Tensor[] split(ReadOnlySpan<long> sizes, long dim = 0L)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					fixed (long* ptr = sizes)
					{
						NativeMethods.THSTensor_split_with_sizes(Handle, pinnedArray.CreateArray, (IntPtr)ptr, sizes.Length, dim);
						CheckForErrors();
					}
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] split(long[] sizes, long dim = 0L)
			{
				return split((ReadOnlySpan<long>)sizes, dim);
			}

			public Tensor[] split(params long[] sizes)
			{
				return split((ReadOnlySpan<long>)sizes, 0L);
			}

			public Tensor[] tensor_split(long size, long dim = 0L)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_tensor_split_with_size(Handle, pinnedArray.CreateArray, size, dim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public unsafe Tensor[] tensor_split(long[] sizes, long dim = 0L)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					fixed (long* ptr = sizes)
					{
						NativeMethods.THSTensor_tensor_split_with_sizes(Handle, pinnedArray.CreateArray, (IntPtr)ptr, sizes.Length, dim);
						CheckForErrors();
					}
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] tensor_split(Tensor indices, long dim = 0L)
			{
				if (indices.dtype != ScalarType.Int64)
				{
					throw new ArgumentException("Tensor indices should be Int64 in 'tensor_split");
				}
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_tensor_split_with_tensor_sizes(Handle, pinnedArray.CreateArray, indices.Handle, dim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] vsplit(long size)
			{
				if (shape[0] % size != 0L)
				{
					throw new ArgumentException("The first dimension must be evenly divisible by the size");
				}
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_vsplit_with_size(Handle, pinnedArray.CreateArray, size);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public unsafe Tensor[] vsplit(params long[] sizes)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					fixed (long* ptr = sizes)
					{
						NativeMethods.THSTensor_vsplit_with_sizes(Handle, pinnedArray.CreateArray, (IntPtr)ptr, sizes.Length);
						CheckForErrors();
					}
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] vsplit(Tensor indices)
			{
				return tensor_split(indices, 0L);
			}

			public Tensor[] hsplit(long size)
			{
				if (shape[1] % size != 0L)
				{
					throw new ArgumentException("The second dimension must be evenly divisible by the size");
				}
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_hsplit_with_size(Handle, pinnedArray.CreateArray, size);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public unsafe Tensor[] hsplit(params long[] sizes)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					fixed (long* ptr = sizes)
					{
						NativeMethods.THSTensor_hsplit_with_sizes(Handle, pinnedArray.CreateArray, (IntPtr)ptr, sizes.Length);
						CheckForErrors();
					}
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] hsplit(Tensor indices)
			{
				return tensor_split(indices, 1L);
			}

			public Tensor[] dsplit(long size)
			{
				if (shape[2] % size != 0L)
				{
					throw new ArgumentException("The third dimension must be evenly divisible by the size");
				}
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_dsplit_with_size(Handle, pinnedArray.CreateArray, size);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] dsplit((long, long) indices_or_sections)
			{
				return dsplit(indices_or_sections.Item1, indices_or_sections.Item2);
			}

			public Tensor[] dsplit((long, long, long) indices_or_sections)
			{
				return dsplit(indices_or_sections.Item1, indices_or_sections.Item2, indices_or_sections.Item3);
			}

			public Tensor[] dsplit((long, long, long, long) indices_or_sections)
			{
				return dsplit(indices_or_sections.Item1, indices_or_sections.Item2, indices_or_sections.Item3, indices_or_sections.Item4);
			}

			public unsafe Tensor[] dsplit(params long[] sizes)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					fixed (long* ptr = sizes)
					{
						NativeMethods.THSTensor_dsplit_with_sizes(Handle, pinnedArray.CreateArray, (IntPtr)ptr, sizes.Length);
						CheckForErrors();
					}
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public Tensor[] dsplit(Tensor indices)
			{
				return tensor_split(indices, 2L);
			}

			public Tensor[] chunk(long chunks, long dim = 0L)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_chunk(Handle, pinnedArray.CreateArray, chunks, dim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return array.Select((IntPtr x) => new Tensor(x)).ToArray();
			}

			public (Tensor values, Tensor indices) kthvalue(long k, long? dim, bool keepdim = false)
			{
				IntPtr _out;
				IntPtr intPtr = NativeMethods.THSTensor_kthvalue(Handle, k, dim.HasValue ? dim.Value : (-1), keepdim, out _out);
				if (intPtr == IntPtr.Zero || _out == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (values: new Tensor(intPtr), indices: new Tensor(_out));
			}

			[Obsolete("use torch.kthvalue", false)]
			public static (Tensor values, Tensor indices) kthvalue(Tensor input, long k, long? dim, bool keepdim = false)
			{
				return input.kthvalue(k, dim, keepdim);
			}

			public Tensor max()
			{
				IntPtr intPtr = NativeMethods.THSTensor_max(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor maximum(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_max_elementwise(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor max(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_max_elementwise(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor values, Tensor indexes) max(long dim, bool keepdim = false)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_max_along_dimension(Handle, pinnedArray.CreateArray, dim, keepdim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return (values: new Tensor(array[0]), indexes: new Tensor(array[1]));
			}

			public Tensor mean()
			{
				IntPtr intPtr = NativeMethods.THSTensor_mean(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor quantile(Tensor q, long dim = -1L, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_quantile(Handle, q.Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor nanquantile(Tensor q, long dim = -1L, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_nanquantile(Handle, q.Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor values, Tensor indices) mode(long dim = -1L, bool keepdim = false)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_mode(Handle, pinnedArray.CreateArray, dim, keepdim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return (values: new Tensor(array[0]), indices: new Tensor(array[1]));
			}

			public unsafe Tensor mean(long[] dimensions, bool keepdim = false, ScalarType? type = null)
			{
				fixed (long* ptr = dimensions)
				{
					IntPtr intPtr = NativeMethods.THSTensor_mean_along_dimensions(Handle, (IntPtr)ptr, dimensions.Length, keepdim, type.HasValue, (sbyte)type.GetValueOrDefault());
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor median()
			{
				IntPtr intPtr = NativeMethods.THSTensor_median(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor min()
			{
				IntPtr intPtr = NativeMethods.THSTensor_min(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor min(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_min_elementwise(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor minimum(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_min_elementwise(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor values, Tensor indexes) min(long dim, bool keepdim = false)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_min_along_dimension(Handle, pinnedArray.CreateArray, dim, keepdim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return (values: new Tensor(array[0]), indexes: new Tensor(array[1]));
			}

			public Tensor msort()
			{
				IntPtr intPtr = NativeMethods.THSTensor_msort(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor Values, Tensor Indices) sort(long dim = -1L, bool descending = false, bool stable = false)
			{
				IntPtr indices;
				IntPtr intPtr = NativeMethods.THSTensor_sort(Handle, dim, descending, stable, out indices);
				if (intPtr == IntPtr.Zero || indices == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (Values: new Tensor(intPtr), Indices: new Tensor(indices));
			}

			public Tensor ne(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ne(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor not_equal(Tensor target)
			{
				return ne(target);
			}

			public Tensor ne_(Tensor target)
			{
				NativeMethods.THSTensor_ne_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor not_equal_(Tensor target)
			{
				return ne_(target);
			}

			public Tensor ne(Scalar target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ne_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ne_(Scalar target)
			{
				NativeMethods.THSTensor_ne_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor dist(Tensor other, float p = 2f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_dist(Handle, other.Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor norm(float p = 2f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_norm(Handle, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor norm(int dim, bool keepdim = false, float p = 2f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_norm_along_dimension(Handle, dim, keepdim, p);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor outer(Tensor vec2)
			{
				IntPtr intPtr = NativeMethods.THSTensor_outer(Handle, vec2.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ger(Tensor vec2)
			{
				return outer(vec2);
			}

			public Tensor inner(Tensor vec2)
			{
				IntPtr intPtr = NativeMethods.THSTensor_inner(Handle, vec2.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor inverse()
			{
				return linalg.inv(this);
			}

			public Tensor prelu(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_prelu(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor fmax(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_fmax(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor fmin(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_fmin(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor renorm(float p, long dim, float maxnorm)
			{
				IntPtr intPtr = NativeMethods.THSTensor_renorm(Handle, p, dim, maxnorm);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sigmoid()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sigmoid(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sigmoid_()
			{
				NativeMethods.THSTensor_sigmoid_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor std(bool unbiased = true)
			{
				IntPtr intPtr = NativeMethods.THSTensor_std(Handle, unbiased);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor var(bool unbiased = true)
			{
				IntPtr intPtr = NativeMethods.THSTensor_var(Handle, unbiased);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor std(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _std(dimensions, unbiased, keepdim, type);
			}

			public Tensor var(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _var(dimensions, unbiased, keepdim, type);
			}

			public Tensor std(long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _std(dimensions, unbiased, keepdim, type);
			}

			public Tensor var(long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _var(dimensions, unbiased, keepdim, type);
			}

			private unsafe Tensor _std(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				fixed (long* ptr = dimensions)
				{
					IntPtr intPtr = NativeMethods.THSTensor_std_along_dimensions(Handle, (IntPtr)ptr, dimensions.Length, unbiased, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			private unsafe Tensor _var(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				fixed (long* ptr = dimensions)
				{
					IntPtr intPtr = NativeMethods.THSTensor_var_along_dimensions(Handle, (IntPtr)ptr, dimensions.Length, unbiased, keepdim);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor std(long dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[1] { dim };
				return std(span, unbiased, keepdim, type);
			}

			public Tensor var(long dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[1] { dim };
				return var(span, unbiased, keepdim, type);
			}

			public Tensor std((long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[2] { dim.Item1, dim.Item2 };
				return std(span, unbiased, keepdim, type);
			}

			public Tensor var((long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[2] { dim.Item1, dim.Item2 };
				return var(span, unbiased, keepdim, type);
			}

			public Tensor std((long, long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[3] { dim.Item1, dim.Item2, dim.Item3 };
				return std(span, unbiased, keepdim, type);
			}

			public Tensor var((long, long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[3] { dim.Item1, dim.Item2, dim.Item3 };
				return var(span, unbiased, keepdim, type);
			}

			public (Tensor std, Tensor mean) std_mean(bool unbiased = true)
			{
				IntPtr intPtr2;
				IntPtr intPtr = NativeMethods.THSTensor_std_mean(Handle, unbiased, out intPtr2);
				if (intPtr == IntPtr.Zero || intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (std: new Tensor(intPtr), mean: new Tensor(intPtr2));
			}

			public (Tensor var, Tensor mean) var_mean(bool unbiased = true)
			{
				IntPtr intPtr2;
				IntPtr intPtr = NativeMethods.THSTensor_var_mean(Handle, unbiased, out intPtr2);
				if (intPtr == IntPtr.Zero || intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (var: new Tensor(intPtr), mean: new Tensor(intPtr2));
			}

			public (Tensor std, Tensor mean) std_mean(long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _std_mean(dimensions, unbiased, keepdim, type);
			}

			public (Tensor std, Tensor mean) var_mean(long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _var_mean(dimensions, unbiased, keepdim, type);
			}

			public (Tensor std, Tensor mean) std_mean(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _std_mean(dimensions, unbiased, keepdim, type);
			}

			public (Tensor std, Tensor mean) var_mean(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return _var_mean(dimensions, unbiased, keepdim, type);
			}

			private unsafe (Tensor std, Tensor mean) _std_mean(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				fixed (long* ptr = dimensions)
				{
					IntPtr intPtr2;
					IntPtr intPtr = NativeMethods.THSTensor_std_mean_along_dimensions(Handle, (IntPtr)ptr, dimensions.Length, unbiased, keepdim, out intPtr2);
					if (intPtr == IntPtr.Zero || intPtr2 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return (std: new Tensor(intPtr), mean: new Tensor(intPtr2));
				}
			}

			private unsafe (Tensor var, Tensor mean) _var_mean(ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				fixed (long* ptr = dimensions)
				{
					IntPtr intPtr2;
					IntPtr intPtr = NativeMethods.THSTensor_var_mean_along_dimensions(Handle, (IntPtr)ptr, dimensions.Length, unbiased, keepdim, out intPtr2);
					if (intPtr == IntPtr.Zero || intPtr2 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return (var: new Tensor(intPtr), mean: new Tensor(intPtr2));
				}
			}

			public (Tensor std, Tensor mean) std_mean(long dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return std_mean(new long[1] { dim }, unbiased, keepdim, type);
			}

			public (Tensor var, Tensor mean) var_mean(long dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				return var_mean(new long[1] { dim }, unbiased, keepdim, type);
			}

			public (Tensor std, Tensor mean) std_mean((long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[2] { dim.Item1, dim.Item2 };
				return std_mean(span, unbiased, keepdim, type);
			}

			public (Tensor var, Tensor mean) var_mean((long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[2] { dim.Item1, dim.Item2 };
				return var_mean(span, unbiased, keepdim, type);
			}

			public (Tensor std, Tensor mean) std_mean((long, long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[3] { dim.Item1, dim.Item2, dim.Item3 };
				return std_mean(span, unbiased, keepdim, type);
			}

			public (Tensor var, Tensor mean) var_mean((long, long, long) dim, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[3] { dim.Item1, dim.Item2, dim.Item3 };
				return var_mean(span, unbiased, keepdim, type);
			}

			public Tensor prod(ScalarType? type = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_prod(Handle, type.HasValue, (sbyte)type.GetValueOrDefault());
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor prod(long dim, bool keepdim = false, ScalarType? type = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_prod_along_dimensions(Handle, dim, keepdim, type.HasValue, (sbyte)type.GetValueOrDefault());
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sum(ScalarType? type = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_sum(Handle, type.HasValue, (sbyte)type.GetValueOrDefault());
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			private unsafe Tensor _sum(ReadOnlySpan<long> dimensions, bool keepdim = false, ScalarType? type = null)
			{
				fixed (long* ptr = dimensions)
				{
					IntPtr intPtr = NativeMethods.THSTensor_sum_along_dimensions(Handle, (IntPtr)ptr, dimensions.Length, keepdim, type.HasValue, (sbyte)type.GetValueOrDefault());
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor sum(long[] dim, bool keepdim = false, ScalarType? type = null)
			{
				return _sum(dim, keepdim, type);
			}

			public Tensor sum(ReadOnlySpan<long> dim, bool keepdim = false, ScalarType? type = null)
			{
				return _sum(dim, keepdim, type);
			}

			public Tensor sum(long dim, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[1] { dim };
				return _sum(span, keepdim, type);
			}

			public Tensor sum(long dim0, long dim1, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[2] { dim0, dim1 };
				return _sum(span, keepdim, type);
			}

			public Tensor sum(long dim0, long dim1, long dim2, bool keepdim = false, ScalarType? type = null)
			{
				Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
				return _sum(span, keepdim, type);
			}

			public unsafe Tensor expand(ReadOnlySpan<long> sizes, bool isImplicit = false)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_expand(Handle, (IntPtr)ptr, sizes.Length, isImplicit);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor expand(Size sizes, bool isImplicit = false)
			{
				return expand((ReadOnlySpan<long>)sizes.Shape, isImplicit);
			}

			public Tensor expand(long[] sizes, bool isImplicit = false)
			{
				return expand((ReadOnlySpan<long>)sizes, isImplicit);
			}

			public Tensor expand_as(Tensor other)
			{
				return expand(other.shape);
			}

			public Tensor expand(params long[] sizes)
			{
				return expand((ReadOnlySpan<long>)sizes, isImplicit: false);
			}

			public unsafe Tensor repeat(params long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_repeat(Handle, (IntPtr)ptr, sizes.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor repeat_interleave(Tensor repeats, long? dim = null, long? output_size = null)
			{
				long num = dim ?? long.MinValue;
				long output_size2 = output_size ?? long.MinValue;
				IntPtr intPtr = NativeMethods.THSTensor_repeat_interleave(Handle, repeats.Handle, num, output_size2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor repeat_interleave(long repeats, long? dim = null, long? output_size = null)
			{
				long num = dim ?? long.MinValue;
				long output_size2 = output_size ?? long.MinValue;
				IntPtr intPtr = NativeMethods.THSTensor_repeat_interleave_int64(Handle, repeats, num, output_size2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor broadcast_to(params long[] shape)
			{
				fixed (long* ptr = shape)
				{
					IntPtr intPtr = NativeMethods.THSTensor_broadcast_to(Handle, (IntPtr)ptr, shape.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe Tensor movedim(long[] source, long[] destination)
			{
				fixed (long* ptr = source)
				{
					fixed (long* ptr2 = destination)
					{
						IntPtr intPtr = NativeMethods.THSTensor_movedim(Handle, (IntPtr)ptr, source.Length, (IntPtr)ptr2, destination.Length);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public Tensor moveaxis(long[] source, long[] destination)
			{
				return movedim(source, destination);
			}

			public unsafe Tensor randn_out(params long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_randn_out((IntPtr)ptr, sizes.Length, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe Tensor rand_out(params long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_rand_out((IntPtr)ptr, sizes.Length, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe Tensor randint_out(long high, long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_randint_out(high, (IntPtr)ptr, sizes.Length, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor rand_like(ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_rand_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_rand_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor randn_like(ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_randn_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_randn_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor randint_like(long low, long high, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_randint_like(Handle, low, high, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_randint_like(Handle, low, high, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			[Obsolete("This doesn't exist in PyTorch.")]
			public Tensor randperm_out(long n)
			{
				IntPtr intPtr = NativeMethods.THSTensor_randperm_out(IntPtr.Zero, n, Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bernoulli(Generator? generator = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bernoulli(Handle, generator?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor multinomial(long num_samples, bool replacement = false, Generator? generator = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_multinomial(Handle, num_samples, replacement, generator?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor poisson(Generator? generator = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_poisson(Handle, generator?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bernoulli_(double p = 0.5, Generator? generator = null)
			{
				NativeMethods.THSTensor_bernoulli_0(Handle, p, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor bernoulli_(Tensor p, Generator? generator = null)
			{
				NativeMethods.THSTensor_bernoulli_1(Handle, p.Handle, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor binomial(Tensor prob, Generator? generator = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_binomial(Handle, prob.Handle, generator?.Handle ?? IntPtr.Zero);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cauchy_(double median = 0.0, double sigma = 1.0, Generator? generator = null)
			{
				NativeMethods.THSTensor_cauchy_(Handle, median, sigma, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor exponential_(double lambda = 1.0, Generator? generator = null)
			{
				NativeMethods.THSTensor_exponential_(Handle, lambda, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor geometric_(double p, Generator? generator = null)
			{
				NativeMethods.THSTensor_geometric_(Handle, p, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor normal_(double mean = 0.0, double std = 1.0, Generator? generator = null)
			{
				NativeMethods.THSTensor_normal_(Handle, mean, std, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor log_normal_(double mean = 0.0, double std = 1.0, Generator? generator = null)
			{
				NativeMethods.THSTensor_log_normal_(Handle, mean, std, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor random_(double from, double to, Generator? generator = null)
			{
				NativeMethods.THSTensor_random_(Handle, from, to, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor uniform_(double from, double to, Generator? generator = null)
			{
				NativeMethods.THSTensor_uniform_(Handle, from, to, generator?.Handle ?? IntPtr.Zero);
				CheckForErrors();
				return this;
			}

			public Tensor arange_out(Scalar start, Scalar stop, Scalar step)
			{
				IntPtr intPtr = NativeMethods.THSTensor_arange_out(start.Handle, stop.Handle, step.Handle, Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor permute(params long[] permutation)
			{
				fixed (long* ptr = permutation)
				{
					IntPtr intPtr = NativeMethods.THSTensor_permute(Handle, (IntPtr)ptr, permutation.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor permute(IEnumerable<long> permutation)
			{
				return permute(permutation.ToArray());
			}

			public unsafe Tensor ones(params long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_ones_out((IntPtr)ptr, sizes.Length, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			private Tensor new_ones(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.ones(size, dtype, device, requires_grad, (string[]?)null);
			}

			private Tensor new_ones(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.ones(size, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_ones(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_ones(new long[1] { size }, dtype, device, requires_grad);
			}

			public Tensor new_ones(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_ones(new long[2] { rows, columns }, dtype, device, requires_grad);
			}

			public Tensor new_ones(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_ones(new long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad);
			}

			public Tensor new_ones(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_ones(new long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad);
			}

			public unsafe Tensor zeros(params long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_zeros_out((IntPtr)ptr, sizes.Length, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor zero_()
			{
				return zeros(shape);
			}

			public Tensor new_zeros(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.zeros(size, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_zeros(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.zeros(size, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_zeros(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_zeros(new long[1] { size }, dtype, device, requires_grad);
			}

			public Tensor new_zeros(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_zeros(new long[2] { rows, columns }, dtype, device, requires_grad);
			}

			public Tensor new_zeros(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_zeros(new long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad);
			}

			public Tensor new_zeros(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_zeros(new long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad);
			}

			public Tensor zeros_like(ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_zeros_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_zeros_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ones_like(ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_ones_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_ones_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor new_empty(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.empty(size, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_empty(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.empty(size, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_empty(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_empty(new long[1] { size }, dtype, device, requires_grad);
			}

			public Tensor new_empty(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_empty(new long[2] { rows, columns }, dtype, device, requires_grad);
			}

			public Tensor new_empty(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_empty(new long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad);
			}

			public Tensor new_empty(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_empty(new long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad);
			}

			public unsafe Tensor empty(params long[] sizes)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_empty_out((IntPtr)ptr, sizes.Length, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor empty_like(ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_empty_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_empty_like(Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor full(long[] sizes, Scalar value)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_full_out((IntPtr)ptr, sizes.Length, value.Handle, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public unsafe Tensor full(ReadOnlySpan<long> sizes, Scalar value)
			{
				fixed (long* ptr = sizes)
				{
					IntPtr intPtr = NativeMethods.THSTensor_full_out((IntPtr)ptr, sizes.Length, value.Handle, Handle);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor new_full(long[] size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.full(size, value, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_full(ReadOnlySpan<long> size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				if (device == null)
				{
					device = this.device;
				}
				if (!dtype.HasValue)
				{
					dtype = this.dtype;
				}
				return torch.full(size, value, dtype, device, requires_grad, (string[]?)null);
			}

			public Tensor new_full(long size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_full(new long[1] { size }, value, dtype, device, requires_grad);
			}

			public Tensor new_full(long rows, long columns, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_full(new long[2] { rows, columns }, value, dtype, device, requires_grad);
			}

			public Tensor new_full(long dim0, long dim1, long dim2, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_full(new long[3] { dim0, dim1, dim2 }, value, dtype, device, requires_grad);
			}

			public Tensor new_full(long dim0, long dim1, long dim2, long dim3, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				return new_full(new long[4] { dim0, dim1, dim2, dim3 }, value, dtype, device, requires_grad);
			}

			public Tensor full_like(Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
			{
				dtype = dtype ?? new ScalarType?(this.dtype);
				device = ((device == null) ? this.device : device);
				IntPtr intPtr = NativeMethods.THSTensor_full_like(Handle, value.Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_full_like(Handle, value.Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor detach()
			{
				IntPtr intPtr = NativeMethods.THSTensor_detach(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor detach_()
			{
				NativeMethods.THSTensor_detach_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor eye(long rows, long columns)
			{
				IntPtr intPtr = NativeMethods.THSTensor_eye_out(rows, columns, Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor scatter(long dim, Tensor index, Tensor src)
			{
				IntPtr intPtr = NativeMethods.THSTensor_scatter(Handle, dim, index.Handle, src.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor scatter_(long dim, Tensor index, Tensor src)
			{
				NativeMethods.THSTensor_scatter_(Handle, dim, index.Handle, src.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor scatter_add(long dim, Tensor index, Tensor src)
			{
				IntPtr intPtr = NativeMethods.THSTensor_scatter_add(Handle, dim, index.Handle, src.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor scatter_add_(long dim, Tensor index, Tensor src)
			{
				NativeMethods.THSTensor_scatter_add_(Handle, dim, index.Handle, src.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor diagonal_scatter(Tensor src, long offset = 0L, long dim1 = 0L, long dim2 = 1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_diagonal_scatter(Handle, src.Handle, offset, dim1, dim2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor select_scatter(Tensor src, long dim, long index)
			{
				IntPtr intPtr = NativeMethods.THSTensor_select_scatter(Handle, src.Handle, dim, index);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor slice_scatter(Tensor src, long dim = 0L, long? start = null, long? end = null, long step = 1L)
			{
				long[] array = ((!start.HasValue) ? null : new long[1] { start.Value });
				long[] obj = ((!end.HasValue) ? null : new long[1] { end.Value });
				fixed (long* ptr = array)
				{
					fixed (long* ptr2 = obj)
					{
						IntPtr intPtr = NativeMethods.THSTensor_slice_scatter(Handle, src.Handle, dim, (IntPtr)ptr, (IntPtr)ptr2, step);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public Tensor gather(long dim, Tensor index)
			{
				IntPtr intPtr = NativeMethods.THSTensor_gather(Handle, dim, index.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor flip(params long[] dims)
			{
				fixed (long* ptr = dims)
				{
					IntPtr intPtr = NativeMethods.THSTensor_flip(Handle, (IntPtr)ptr, dims.Length);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor fliplr()
			{
				IntPtr intPtr = NativeMethods.THSTensor_fliplr(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor flipud()
			{
				IntPtr intPtr = NativeMethods.THSTensor_flipud(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor nanmean(int? dim = null, bool keepdim = false, ScalarType? dtype = null)
			{
				int num = ((!dim.HasValue) ? (-1) : dim.Value);
				ScalarType scalar_type = ((!dtype.HasValue) ? this.dtype : dtype.Value);
				IntPtr intPtr = NativeMethods.THSTensor_nanmean(Handle, num, keepdim, (sbyte)scalar_type);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor nanmedian()
			{
				IntPtr intPtr = NativeMethods.THSTensor_nanmedian(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor nansum()
			{
				IntPtr intPtr = NativeMethods.THSTensor_nansum(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor nan_to_num(double nan = 0.0, double? posinf = null, double? neginf = null)
			{
				double[] array = new double[1] { nan };
				double[] array2 = ((!posinf.HasValue) ? null : new double[1] { posinf.Value });
				double[] obj = ((!neginf.HasValue) ? null : new double[1] { neginf.Value });
				fixed (double* ptr = array)
				{
					fixed (double* ptr2 = array2)
					{
						fixed (double* ptr3 = obj)
						{
							IntPtr intPtr = NativeMethods.THSTensor_nan_to_num(Handle, (IntPtr)ptr, (IntPtr)ptr2, (IntPtr)ptr3);
							if (intPtr == IntPtr.Zero)
							{
								CheckForErrors();
							}
							return new Tensor(intPtr);
						}
					}
				}
			}

			public Tensor nextafter(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_nextafter(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor narrow(long dim, long start, long length)
			{
				IntPtr intPtr = NativeMethods.THSTensor_narrow(Handle, dim, start, length);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor nonzero()
			{
				IntPtr intPtr = NativeMethods.THSTensor_nonzero(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public IList<Tensor> nonzero_as_list()
			{
				IntPtr intPtr = NativeMethods.THSTensor_nonzero(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				return tensor.chunk(tensor.shape[1], 1L);
			}

			public Tensor roll(long shifts, long? dims = null)
			{
				Span<long> span;
				if (dims.HasValue)
				{
					span = stackalloc long[1] { shifts };
					return _roll(span, new long[1] { dims.Value });
				}
				span = stackalloc long[1] { shifts };
				return _roll(span, null);
			}

			public Tensor roll((long, long) shifts, (long, long) dims)
			{
				Span<long> span = stackalloc long[2] { shifts.Item1, shifts.Item2 };
				return _roll(span, new long[2] { dims.Item1, dims.Item2 });
			}

			public Tensor roll(long[] shifts, long[] dims)
			{
				return _roll(shifts, dims);
			}

			public Tensor roll(long[] shifts)
			{
				return _roll(shifts, new long[1]);
			}

			public Tensor rot90(long k = 1L, (long, long)? dims = null)
			{
				if (!dims.HasValue)
				{
					dims = (0L, 1L);
				}
				IntPtr intPtr = NativeMethods.THSTensor_rot90(Handle, k, dims.Value.Item1, dims.Value.Item2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor roll((long, long, long) shifts, (long, long, long) dims)
			{
				Span<long> span = stackalloc long[3] { shifts.Item1, shifts.Item2, shifts.Item3 };
				return _roll(span, new long[3] { dims.Item1, dims.Item2, dims.Item3 });
			}

			public Tensor roll(ReadOnlySpan<long> shifts, ReadOnlySpan<long> dims = default(ReadOnlySpan<long>))
			{
				return _roll(shifts, dims);
			}

			private unsafe Tensor _roll(ReadOnlySpan<long> shifts, ReadOnlySpan<long> dims)
			{
				int length = dims.Length;
				fixed (long* ptr = shifts)
				{
					fixed (long* ptr2 = ((length == 0) ? ((ReadOnlySpan<long>)null) : dims))
					{
						IntPtr intPtr = NativeMethods.THSTensor_roll(Handle, (IntPtr)ptr, shifts.Length, (IntPtr)ptr2, length);
						if (intPtr == IntPtr.Zero)
						{
							CheckForErrors();
						}
						return new Tensor(intPtr);
					}
				}
			}

			public Tensor slice(long dim, long start, long finish, long step)
			{
				if (step < 1)
				{
					throw new ArgumentException($"step is {step}, but it should always be positive.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_slice(Handle, dim, start, finish, step);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor unsqueeze(long dim)
			{
				IntPtr intPtr = NativeMethods.THSTensor_unsqueeze(Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor unsqueeze_(long dim)
			{
				NativeMethods.THSTensor_unsqueeze_(Handle, dim);
				CheckForErrors();
				return this;
			}

			public Tensor where(Tensor condition, Tensor y)
			{
				if (condition.dtype != ScalarType.Bool)
				{
					throw new ArgumentException("The condition to 'where' must be a boolean tensor.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_where(condition.Handle, Handle, y.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor operator ==(Tensor left, Tensor right)
			{
				return left.eq(right);
			}

			public static Tensor operator ==(Tensor left, Scalar right)
			{
				return left.eq(right);
			}

			public static Tensor operator ==(Scalar left, Tensor right)
			{
				return right.eq(left);
			}

			public static Tensor operator !=(Tensor left, Tensor right)
			{
				return left.ne(right);
			}

			public static Tensor operator !=(Tensor left, Scalar right)
			{
				return left.ne(right);
			}

			public static Tensor operator !=(Scalar left, Tensor right)
			{
				return right.ne(left);
			}

			public static Tensor operator <(Tensor left, Tensor right)
			{
				return left.lt(right);
			}

			public static Tensor operator <(Tensor left, Scalar right)
			{
				return left.lt(right);
			}

			public static Tensor operator <(Scalar left, Tensor right)
			{
				return right.gt(left);
			}

			public static Tensor operator <=(Tensor left, Tensor right)
			{
				return left.le(right);
			}

			public static Tensor operator <=(Tensor left, Scalar right)
			{
				return left.le(right);
			}

			public static Tensor operator <=(Scalar left, Tensor right)
			{
				return right.ge(left);
			}

			public static Tensor operator >(Tensor left, Tensor right)
			{
				return left.gt(right);
			}

			public static Tensor operator >(Tensor left, Scalar right)
			{
				return left.gt(right);
			}

			public static Tensor operator >(Scalar left, Tensor right)
			{
				return right.lt(left);
			}

			public static Tensor operator >=(Tensor left, Tensor right)
			{
				return left.ge(right);
			}

			public static Tensor operator >=(Tensor left, Scalar right)
			{
				return left.ge(right);
			}

			public static Tensor operator >=(Scalar left, Tensor right)
			{
				return right.le(left);
			}

			public static implicit operator Tensor(byte value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(sbyte value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(short value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(int value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(long value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(float value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(double value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(bool value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor((float, float) value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(Complex value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(byte[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(sbyte[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(short[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(int[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(long[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(float[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(double[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(bool[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor((float, float)[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(Complex[] value)
			{
				return tensor(value);
			}

			public static implicit operator Tensor(Scalar scalar)
			{
				_throw();
				return new Tensor(IntPtr.Zero);
			}

			private static void _throw()
			{
				throw new InvalidOperationException("Should not be called.");
			}

			public static Tensor op_MinusMinusGreater(Tensor t, nn.Module<Tensor, Tensor> m)
			{
				return m.call(t);
			}

			public override string ToString()
			{
				return ToMetadataString();
			}

			public string ToString(bool disamb, string? fltFormat = null, int? width = null, CultureInfo? cultureInfo = null, string? newLine = null)
			{
				if (!disamb)
				{
					return ToMetadataString();
				}
				return ToString(TensorStringStyle, fltFormat, width, cultureInfo, newLine);
			}

			public string ToString(TensorStringStyle style, string? fltFormat = null, int? width = null, CultureInfo? cultureInfo = null, string? newLine = null)
			{
				int width2 = width ?? lineWidth;
				string newLine2 = newLine ?? torch.newLine;
				string fltFormat2 = fltFormat ?? floatFormat;
				if (style == TensorStringStyle.Default)
				{
					style = TensorStringStyle;
				}
				if (device_type == DeviceType.META)
				{
					style = TensorStringStyle.Metadata;
				}
				return style switch
				{
					TensorStringStyle.Metadata => ToMetadataString(), 
					TensorStringStyle.Julia => ToJuliaString(fltFormat2, width2, cultureInfo, newLine2), 
					TensorStringStyle.Numpy => ToNumpyString(this, ndim, isFCreate: true, fltFormat2, cultureInfo, newLine2), 
					TensorStringStyle.CSharp => ToCSharpString(this, ndim, isFCreate: true, fltFormat2, cultureInfo, newLine2, top: true), 
					_ => throw new InvalidEnumArgumentException($"Unsupported tensor string style: {style}"), 
				};
			}

			private string ToMetadataString()
			{
				if (Handle == IntPtr.Zero)
				{
					return "";
				}
				StringBuilder stringBuilder = new StringBuilder("[");
				long dimensions = Dimensions;
				if (dimensions == 0L)
				{
					stringBuilder.Append(']');
				}
				else
				{
					for (int i = 0; i < dimensions; i++)
					{
						stringBuilder.Append(size(i));
						if (i + 1 < dimensions)
						{
							stringBuilder.Append("x");
						}
					}
					stringBuilder.Append("]");
				}
				stringBuilder.Append($", type = {dtype}, device = {device}");
				return stringBuilder.ToString();
			}

			private static string ToNumpyString(Tensor t, long mdim, bool isFCreate, string fltFormat, CultureInfo? cultureInfo, string newLine)
			{
				CultureInfo cultureInfo2 = cultureInfo ?? CultureInfo.CurrentCulture;
				int num = maxColumns / 2;
				int num2 = maxColumns - num;
				int num3 = maxRows / 2;
				int num4 = maxRows - num3;
				long num5 = t.dim();
				StringBuilder stringBuilder = new StringBuilder(isFCreate ? string.Join("", Enumerable.Repeat(' ', (int)(mdim - num5))) : "");
				if (num5 == 0L)
				{
					PrintValue(stringBuilder, t.dtype, t.ToScalar(), fltFormat, cultureInfo2);
					return stringBuilder.ToString();
				}
				stringBuilder.Append('[');
				long num6 = t.size()[0];
				if (num6 != 0L)
				{
					if (num5 == 1)
					{
						if (num6 <= maxColumns)
						{
							for (int i = 0; i < num6 - 1; i++)
							{
								PrintValue(stringBuilder, t.dtype, t[i].ToScalar(), fltFormat, cultureInfo2);
								stringBuilder.Append(',').Append(' ');
							}
							PrintValue(stringBuilder, t.dtype, t[num6 - 1].ToScalar(), fltFormat, cultureInfo2);
						}
						else
						{
							for (int j = 0; j < num2; j++)
							{
								PrintValue(stringBuilder, t.dtype, t[j].ToScalar(), fltFormat, cultureInfo2);
								stringBuilder.Append(',').Append(' ');
							}
							stringBuilder.Append("... ");
							for (long num7 = num6 - num; num7 < num6 - 1; num7++)
							{
								PrintValue(stringBuilder, t.dtype, t[num7].ToScalar(), fltFormat, cultureInfo2);
								stringBuilder.Append(',').Append(' ');
							}
							PrintValue(stringBuilder, t.dtype, t[num6 - 1].ToScalar(), fltFormat, cultureInfo2);
						}
					}
					else
					{
						string value = string.Join("", Enumerable.Repeat(newLine, (int)num5 - 1).ToList());
						if (num6 == 1)
						{
							stringBuilder.Append(ToNumpyString(t[0L], mdim, isFCreate: false, fltFormat, cultureInfo, newLine));
						}
						else if (num6 <= maxRows)
						{
							stringBuilder.Append(ToNumpyString(t[0L], mdim, isFCreate: false, fltFormat, cultureInfo, newLine));
							stringBuilder.Append(value);
							for (int k = 1; k < num6 - 1; k++)
							{
								stringBuilder.Append(ToNumpyString(t[k], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
								stringBuilder.Append(value);
							}
							stringBuilder.Append(ToNumpyString(t[num6 - 1], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
						}
						else
						{
							stringBuilder.Append(ToNumpyString(t[0L], mdim, isFCreate: false, fltFormat, cultureInfo, newLine));
							stringBuilder.Append(value);
							for (int l = 1; l < num4; l++)
							{
								stringBuilder.Append(ToNumpyString(t[l], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
								stringBuilder.Append(value);
							}
							stringBuilder.Append(string.Join("", Enumerable.Repeat(' ', (int)(mdim - num5))));
							stringBuilder.Append(" ...");
							stringBuilder.Append(value);
							for (long num8 = num6 - num3; num8 < num6 - 1; num8++)
							{
								stringBuilder.Append(ToNumpyString(t[num8], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
								stringBuilder.Append(value);
							}
							stringBuilder.Append(ToNumpyString(t[num6 - 1], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
						}
					}
				}
				stringBuilder.Append("]");
				return stringBuilder.ToString();
			}

			private static string ToCSharpString(Tensor t, long mdim, bool isFCreate, string fltFormat, CultureInfo? cultureInfo, string newLine, bool top = false)
			{
				CultureInfo cultureInfo2 = cultureInfo ?? CultureInfo.CurrentCulture;
				int num = maxColumns / 2;
				int num2 = maxColumns - num;
				int num3 = maxRows / 2;
				int num4 = maxRows - num3;
				long num5 = t.dim();
				StringBuilder stringBuilder = new StringBuilder();
				if (top)
				{
					stringBuilder.Append(t.ToMetadataString());
					stringBuilder.Append(", value = ");
					if (t.Dimensions == 0L)
					{
						PrintValue(stringBuilder, t.dtype, t.ToScalar(), fltFormat, cultureInfo2);
						return stringBuilder.ToString();
					}
				}
				if (top && t.Dimensions > 1)
				{
					stringBuilder.Append(newLine);
				}
				string value = "";
				switch (t.dtype)
				{
				default:
					return t.ToMetadataString();
				case ScalarType.Bool:
					if (top)
					{
						stringBuilder.Append("bool ");
					}
					break;
				case ScalarType.Byte:
					if (top)
					{
						stringBuilder.Append("byte ");
					}
					break;
				case ScalarType.Int8:
					if (top)
					{
						stringBuilder.Append("sbyte ");
					}
					break;
				case ScalarType.Int16:
					if (top)
					{
						stringBuilder.Append("short ");
					}
					break;
				case ScalarType.Int32:
					if (top)
					{
						stringBuilder.Append("int ");
					}
					break;
				case ScalarType.Int64:
					if (top)
					{
						stringBuilder.Append("long ");
					}
					value = "L";
					break;
				case ScalarType.Float32:
					if (top)
					{
						stringBuilder.Append("float ");
					}
					value = "f";
					break;
				case ScalarType.Float64:
					if (top)
					{
						stringBuilder.Append("double ");
					}
					break;
				case ScalarType.ComplexFloat32:
					if (top)
					{
						stringBuilder.Append("complex32 ");
					}
					break;
				case ScalarType.ComplexFloat64:
					if (top)
					{
						stringBuilder.Append("complex64 ");
					}
					break;
				}
				if (top)
				{
					stringBuilder.Append('[');
					for (int i = 0; i < t.Dimensions - 1; i++)
					{
						stringBuilder.Append(',');
					}
					stringBuilder.Append("] ");
				}
				if (isFCreate)
				{
					stringBuilder.Append(string.Join("", Enumerable.Repeat(' ', (int)(mdim - num5))));
				}
				stringBuilder.Append('{');
				if (top && t.Dimensions > 1)
				{
					stringBuilder.Append(newLine);
					stringBuilder.Append(' ');
				}
				long num6 = t.size()[0];
				if (num6 != 0L)
				{
					if (num5 == 1)
					{
						if (num6 <= maxColumns)
						{
							for (int j = 0; j < num6 - 1; j++)
							{
								PrintValue(stringBuilder, t.dtype, t[j].ToScalar(), fltFormat, cultureInfo2);
								stringBuilder.Append(value);
								stringBuilder.Append(',').Append(' ');
							}
							PrintValue(stringBuilder, t.dtype, t[num6 - 1].ToScalar(), fltFormat, cultureInfo2);
							stringBuilder.Append(value);
						}
						else
						{
							for (int k = 0; k < num2; k++)
							{
								PrintValue(stringBuilder, t.dtype, t[k].ToScalar(), fltFormat, cultureInfo2);
								stringBuilder.Append(value);
								stringBuilder.Append(',').Append(' ');
							}
							stringBuilder.Append("... ");
							for (long num7 = num6 - num; num7 < num6 - 1; num7++)
							{
								PrintValue(stringBuilder, t.dtype, t[num7].ToScalar(), fltFormat, cultureInfo2);
								stringBuilder.Append(value);
								stringBuilder.Append(',').Append(' ');
							}
							PrintValue(stringBuilder, t.dtype, t[num6 - 1].ToScalar(), fltFormat, cultureInfo2);
							stringBuilder.Append(value);
						}
					}
					else if (num6 == 1)
					{
						stringBuilder.Append(ToCSharpString(t[0L], mdim, isFCreate: false, fltFormat, cultureInfo, newLine));
					}
					else if (num6 <= maxRows)
					{
						stringBuilder.Append(ToCSharpString(t[0L], mdim, isFCreate: false, fltFormat, cultureInfo, newLine));
						stringBuilder.Append(',').Append(newLine);
						for (int l = 1; l < num6 - 1; l++)
						{
							stringBuilder.Append(ToCSharpString(t[l], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
							stringBuilder.Append(',').Append(newLine);
						}
						stringBuilder.Append(ToCSharpString(t[num6 - 1], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
					}
					else
					{
						stringBuilder.Append(ToCSharpString(t[0L], mdim, isFCreate: false, fltFormat, cultureInfo, newLine));
						stringBuilder.Append(',').Append(newLine);
						for (int m = 1; m < num4; m++)
						{
							stringBuilder.Append(ToCSharpString(t[m], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
							stringBuilder.Append(',').Append(newLine);
						}
						stringBuilder.Append(string.Join("", Enumerable.Repeat(' ', (int)(mdim - num5))));
						stringBuilder.Append(" ...");
						stringBuilder.Append(newLine);
						for (long num8 = num6 - num3; num8 < num6 - 1; num8++)
						{
							stringBuilder.Append(ToCSharpString(t[num8], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
							stringBuilder.Append(',').Append(newLine);
						}
						stringBuilder.Append(ToCSharpString(t[num6 - 1], mdim, isFCreate: true, fltFormat, cultureInfo, newLine));
					}
				}
				if (top && t.Dimensions > 1)
				{
					stringBuilder.Append(newLine);
				}
				stringBuilder.Append("}");
				return stringBuilder.ToString();
			}

			private string ToJuliaString(string fltFormat, int width, CultureInfo? cultureInfo, string newLine)
			{
				CultureInfo cultureInfo2 = cultureInfo ?? CultureInfo.CurrentCulture;
				StringBuilder stringBuilder = new StringBuilder(ToMetadataString());
				if (Dimensions == 0L)
				{
					stringBuilder.Append(", value = ");
					PrintValue(stringBuilder, dtype, ToScalar(), fltFormat, cultureInfo2);
				}
				else if (Dimensions == 1)
				{
					List<string> list = new List<string>();
					BuildRow(list, this, width, fltFormat, cultureInfo2);
					bool appendEllipsis = list.Count < shape[0];
					stringBuilder.Append(newLine);
					PrintOneRow(list, list.Select((string str) => str.Length).ToArray(), new bool[shape[0]], fltFormat, stringBuilder, this, appendEllipsis, newLine);
				}
				else if (Dimensions == 2)
				{
					stringBuilder.Append(newLine);
					PrintTwoDimensions(fltFormat, width, stringBuilder, this, cultureInfo2, newLine);
				}
				else
				{
					List<TensorIndex> indices = new List<TensorIndex>();
					RecursivePrintDimensions(0, indices, fltFormat, width, stringBuilder, cultureInfo2, newLine);
				}
				return stringBuilder.ToString();
			}

			private void RecursivePrintDimensions(int dim, IEnumerable<TensorIndex> indices, string fltFormat, int width, StringBuilder builder, CultureInfo cultureInfo, string newLine)
			{
				if (dim == Dimensions - 3)
				{
					for (int i = 0; i < shape[dim]; i++)
					{
						TensorIndex[] indices2 = indices.Append(TensorIndex.Single(i)).Append(TensorIndex.Ellipsis).Append(TensorIndex.Ellipsis)
							.ToArray();
						string text = IndicesToString(indices2);
						builder.Append(newLine).Append(text + " =").Append(newLine);
						Tensor tensor = index(indices2);
						PrintTwoDimensions(fltFormat, width, builder, tensor, cultureInfo, newLine);
					}
				}
				else
				{
					for (int j = 0; j < shape[dim]; j++)
					{
						RecursivePrintDimensions(dim + 1, indices.Append(TensorIndex.Single(j)), fltFormat, width, builder, cultureInfo, newLine);
					}
				}
			}

			private string IndicesToString(IList<TensorIndex> indices)
			{
				StringBuilder stringBuilder = new StringBuilder("[");
				for (int i = 0; i < indices.Count(); i++)
				{
					if (i > 0)
					{
						stringBuilder.Append(',');
					}
					if (indices[i].kind == TensorIndex.Kind.Ellipsis)
					{
						stringBuilder.Append("..");
					}
					else if (indices[i].kind == TensorIndex.Kind.Single)
					{
						stringBuilder.Append(indices[i].startIndexOrBoolOrSingle);
					}
				}
				return stringBuilder.Append(']').ToString();
			}

			private static void PrintTwoDimensions(string fltFormat, int width, StringBuilder builder, Tensor t, CultureInfo cultureInfo, string newLine)
			{
				List<List<string>> list = new List<List<string>>();
				long num = t.shape[0];
				long num2 = t.shape[1];
				int[] array = new int[num2];
				bool[] array2 = new bool[num2];
				for (int i = 0; i < num; i++)
				{
					List<string> row = new List<string>();
					BuildRow(row, t[i], width, fltFormat, cultureInfo);
					list.Add(row);
				}
				int num3 = list.Select((List<string> r) => r.Count).Min();
				bool appendEllipsis = num3 < t.shape[1];
				for (int num4 = 0; num4 < num; num4++)
				{
					List<string> list2 = list[num4];
					for (int num5 = 0; num5 < num3; num5++)
					{
						array2[num5] = array2[num5] || NSExtension.StartsWith(list2[num5], '-');
						if (list2[num5].Length > array[num5])
						{
							array[num5] = list2[num5].Length;
						}
					}
				}
				for (int num6 = 0; num6 < num; num6++)
				{
					PrintOneRow(list[num6].Take(num3).ToList(), array, array2, fltFormat, builder, t[num6], appendEllipsis, newLine);
				}
			}

			private static void PrintOneRow(IList<string> row, int[] space, bool[] hasMinus, string fltFormat, StringBuilder builder, Tensor rowTensor, bool appendEllipsis, string newLine)
			{
				for (int i = 0; i < row.Count; i++)
				{
					int num = space[i] - row[i].Length;
					builder.Append(' ');
					for (int j = 0; j < num; j++)
					{
						builder.Append(' ');
					}
					builder.Append(row[i]);
				}
				if (appendEllipsis)
				{
					builder.Append(' ').Append("...");
				}
				builder.Append(newLine);
			}

			private static void BuildRow(List<string> row, Tensor t, int width, string fltFormat, CultureInfo cultureInfo)
			{
				ScalarType scalarType = t.dtype;
				int num = "...".Length + 1;
				for (int i = 0; i < t.shape[0]; i++)
				{
					StringBuilder stringBuilder = new StringBuilder();
					PrintValue(stringBuilder, scalarType, t[i].ToScalar(), fltFormat, cultureInfo);
					string text = stringBuilder.ToString();
					if (width - text.Length - num >= 0)
					{
						row.Add(text);
						width -= text.Length + 1;
						continue;
					}
					break;
				}
			}

			private static void PrintValue(StringBuilder builder, ScalarType type, Scalar value, string fltFormat, CultureInfo cultureInfo)
			{
				switch (type)
				{
				case ScalarType.Byte:
					builder.Append(value.ToByte());
					break;
				case ScalarType.Int8:
					builder.Append(value.ToSByte());
					break;
				case ScalarType.Int16:
					builder.Append(value.ToInt16());
					break;
				case ScalarType.Int32:
					builder.Append(value.ToInt32());
					break;
				case ScalarType.Int64:
					builder.Append(value.ToInt64());
					break;
				case ScalarType.Bool:
					builder.Append(value.ToBoolean().ToString(cultureInfo));
					break;
				case ScalarType.Float16:
					builder.Append(value.ToSingle().ToString(fltFormat, cultureInfo));
					break;
				case ScalarType.Float32:
					builder.Append(value.ToSingle().ToString(fltFormat, cultureInfo));
					break;
				case ScalarType.Float64:
					builder.Append(value.ToDouble().ToString(fltFormat, cultureInfo));
					break;
				case ScalarType.ComplexFloat32:
				{
					(float, float) tuple = value.ToComplexFloat32();
					if (tuple.Item1 != 0f || tuple.Item2 == 0f)
					{
						builder.Append(tuple.Item1.ToString(fltFormat, cultureInfo));
						if (tuple.Item2 != 0f)
						{
							builder.Append('+');
						}
					}
					if (tuple.Item2 != 0f)
					{
						builder.Append(tuple.Item2.ToString(fltFormat, cultureInfo)).Append('i');
					}
					break;
				}
				case ScalarType.ComplexFloat64:
				{
					Complex complex = value.ToComplexFloat64();
					if (complex.Real != 0.0 || complex.Imaginary == 0.0)
					{
						builder.Append(complex.Real.ToString(fltFormat, cultureInfo));
						if (complex.Imaginary != 0.0)
						{
							builder.Append('+');
						}
					}
					if (complex.Imaginary != 0.0)
					{
						builder.Append(complex.Imaginary.ToString(fltFormat, cultureInfo)).Append('i');
					}
					break;
				}
				case (ScalarType)8:
					break;
				}
			}

			public object tolist()
			{
				if (shape.Length == 0)
				{
					return ToScalar();
				}
				ArrayList arrayList = new ArrayList();
				if (shape.Length == 1)
				{
					for (long num = 0L; num < shape[0]; num++)
					{
						arrayList.Add(this[num].ToScalar());
					}
				}
				else
				{
					for (long num2 = 0L; num2 < shape[0]; num2++)
					{
						arrayList.Add(this[num2].tolist());
					}
				}
				return arrayList;
			}

			public static explicit operator float(Tensor value)
			{
				return value.ToSingle();
			}

			public static explicit operator double(Tensor value)
			{
				return value.ToDouble();
			}

			public static explicit operator sbyte(Tensor value)
			{
				return value.ToSByte();
			}

			public static explicit operator byte(Tensor value)
			{
				return value.ToByte();
			}

			public static explicit operator short(Tensor value)
			{
				return value.ToInt16();
			}

			public static explicit operator int(Tensor value)
			{
				return value.ToInt32();
			}

			public static explicit operator long(Tensor value)
			{
				return value.ToInt64();
			}

			public static explicit operator bool(Tensor value)
			{
				return value.ToBoolean();
			}

			public static Tensor block_diag(params Tensor[] tensors)
			{
				return torch.block_diag(tensors);
			}

			public Tensor atleast_1d()
			{
				IntPtr intPtr = NativeMethods.THSTensor_atleast_1d(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor atleast_2d()
			{
				IntPtr intPtr = NativeMethods.THSTensor_atleast_2d(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor atleast_3d()
			{
				IntPtr intPtr = NativeMethods.THSTensor_atleast_3d(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor stft(long n_fft, long hop_length = -1L, long win_length = -1L, Tensor? window = null, bool center = true, PaddingModes pad_mode = PaddingModes.Reflect, bool normalized = false, bool? onesided = null, bool? return_complex = null)
			{
				IntPtr x = Handle;
				long onesided2 = -1L;
				if (onesided.HasValue)
				{
					onesided2 = (onesided.Value ? 1 : 0);
				}
				bool return_complex2 = (return_complex.HasValue ? return_complex.Value : is_complex());
				if (center)
				{
					long num = dim();
					long num2 = n_fft / 2;
					long[] array = Enumerable.Repeat(1L, (int)(3 - num)).Concat(shape).ToArray();
					Tensor input = view(array);
					Span<long> span = stackalloc long[2] { num2, num2 };
					Tensor tensor = nn.functional.pad(input, span, pad_mode);
					long[] array2 = tensor.shape;
					long[] array3 = new long[num];
					for (int i = 0; i < num; i++)
					{
						array3[i] = array2[array2.Length + i - num];
					}
					tensor = tensor.view(array3);
					x = tensor.Handle;
				}
				IntPtr window2 = window?.Handle ?? IntPtr.Zero;
				IntPtr intPtr = NativeMethods.THSTensor_stft(x, n_fft, hop_length, win_length, window2, normalized, onesided2, return_complex2);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor istft(long n_fft, long hop_length = -1L, long win_length = -1L, Tensor? window = null, bool center = true, bool normalized = false, bool? onesided = null, long length = -1L, bool return_complex = false)
			{
				_ = shape[1];
				IntPtr window2 = window?.Handle ?? IntPtr.Zero;
				long onesided2 = -1L;
				if (onesided.HasValue)
				{
					onesided2 = (onesided.Value ? 1 : 0);
				}
				IntPtr intPtr = NativeMethods.THSTensor_istft(Handle, n_fft, hop_length, win_length, window2, center, normalized, onesided2, length, return_complex);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe Tensor tensordot(Tensor b, long[] dims1, long[] dims2)
			{
				IntPtr intPtr;
				fixed (long* ptr = dims1)
				{
					fixed (long* ptr2 = dims2)
					{
						intPtr = NativeMethods.THSLinalg_tensordot(Handle, b.Handle, (IntPtr)ptr, dims1.Length, (IntPtr)ptr2, dims2.Length);
					}
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor tensordot(Tensor b, (long, long)[] dims)
			{
				return tensordot(b, dims.Select(((long, long) t) => t.Item1).ToArray(), dims.Select(((long, long) t) => t.Item2).ToArray());
			}

			public Tensor tensordot(Tensor b, long dims = 2L)
			{
				if (dims < 0)
				{
					throw new ArgumentOutOfRangeException("dims", dims, "must be >= 0");
				}
				long[] array = new long[dims];
				for (long num = 0L; num <= dims; num++)
				{
					array[num] = num;
				}
				return tensordot(b, array, array);
			}

			public Tensor cholesky(bool upper = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cholesky(Handle, upper);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cholesky_inverse(bool upper = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cholesky_inverse(Handle, upper);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cholesky_solve(Tensor input2, bool upper = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cholesky_solve(Handle, input2.Handle, upper);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cross(Scalar other, long dim)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cross(Handle, other.Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor det()
			{
				return linalg.det(this);
			}

			public Tensor logdet()
			{
				long[] array = shape;
				int num = array.Length;
				if (array[num - 1] != array[num - 2])
				{
					throw new ArgumentException("The input tensor is not square");
				}
				IntPtr intPtr = NativeMethods.THSTensor_logdet(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor a, Tensor tau) geqrf()
			{
				IntPtr tau;
				IntPtr intPtr = NativeMethods.THSTensor_geqrf(Handle, out tau);
				if (intPtr == IntPtr.Zero || tau == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (a: new Tensor(intPtr), tau: new Tensor(tau));
			}

			public Tensor matmul(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_matmul(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor mm(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_mm(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor mv(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_mv(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor matrix_exp()
			{
				IntPtr intPtr = NativeMethods.THSTensor_matrix_exp(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor matrix_power(int n)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_matrix_power(Handle, n);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor vdot(Tensor target)
			{
				if (shape.Length != 1 || target.shape.Length != 1 || shape[0] != target.shape[0])
				{
					throw new InvalidOperationException("vdot arguments must have the same shape.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_vdot(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor dot(Tensor target)
			{
				if (shape.Length != 1 || target.shape.Length != 1 || shape[0] != target.shape[0])
				{
					throw new InvalidOperationException("dot arguments must have the same shape.");
				}
				IntPtr intPtr = NativeMethods.THSTensor_dot(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor pinverse(double rcond = 1E-15, bool hermitian = false)
			{
				IntPtr intPtr = NativeMethods.THSLinalg_pinverse(Handle, rcond, hermitian);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ormqr(Tensor tau, Tensor other, bool left = true, bool transpose = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ormqr(Handle, tau.handle, other.Handle, left, transpose);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor abs()
			{
				IntPtr intPtr = NativeMethods.THSTensor_abs(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor absolute()
			{
				return abs();
			}

			public Tensor abs_()
			{
				NativeMethods.THSTensor_abs_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor absolute_()
			{
				return abs_();
			}

			public Tensor add(Tensor target)
			{
				return add(target, 1);
			}

			public Tensor add(Tensor target, Scalar alpha)
			{
				IntPtr intPtr = NativeMethods.THSTensor_add(Handle, target.Handle, alpha.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor add(Scalar scalar)
			{
				return add(scalar, 1);
			}

			public Tensor add(Scalar scalar, Scalar alpha)
			{
				IntPtr intPtr = NativeMethods.THSTensor_add_scalar(Handle, scalar.Handle, alpha.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor add_(Tensor target)
			{
				return add_(target, 1);
			}

			public Tensor add_(Tensor target, Scalar alpha)
			{
				NativeMethods.THSTensor_add_(Handle, target.Handle, alpha.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor add_(Scalar scalar)
			{
				return add_(scalar, 1);
			}

			public Tensor add_(Scalar scalar, Scalar alpha)
			{
				NativeMethods.THSTensor_add_scalar_(Handle, scalar.Handle, alpha.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor addbmm(Tensor batch1, Tensor batch2, float beta = 1f, float alpha = 1f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_addbmm(Handle, batch1.Handle, batch2.Handle, beta, alpha);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor addbmm_(Tensor batch1, Tensor batch2, float beta = 1f, float alpha = 1f)
			{
				NativeMethods.THSTensor_addbmm_(Handle, batch1.Handle, batch2.Handle, beta, alpha);
				CheckForErrors();
				return this;
			}

			public Tensor addcdiv(Tensor tensor1, Tensor tensor2, Scalar value)
			{
				IntPtr intPtr = NativeMethods.THSTensor_addcdiv(Handle, tensor1.Handle, tensor2.Handle, value.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor addcdiv(Tensor tensor1, Tensor tensor2)
			{
				return addcdiv(tensor1, tensor2, 1);
			}

			public Tensor addcdiv_(Tensor tensor1, Tensor tensor2, Scalar value)
			{
				NativeMethods.THSTensor_addcdiv_(Handle, tensor1.Handle, tensor2.Handle, value.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor addcdiv_(Tensor tensor1, Tensor tensor2)
			{
				return addcdiv_(tensor1, tensor2, 1);
			}

			public Tensor addcmul(Tensor tensor1, Tensor tensor2, Scalar value)
			{
				IntPtr intPtr = NativeMethods.THSTensor_addcmul(Handle, tensor1.Handle, tensor2.Handle, value.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor addcmul_(Tensor tensor1, Tensor tensor2, Scalar value)
			{
				NativeMethods.THSTensor_addcmul_(Handle, tensor1.Handle, tensor2.Handle, value.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor addmm(Tensor mat1, Tensor mat2, float beta = 1f, float alpha = 1f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_addmm(Handle, mat1.Handle, mat2.Handle, beta, alpha);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor addmm_(Tensor mat1, Tensor mat2, float beta = 1f, float alpha = 1f)
			{
				NativeMethods.THSTensor_addmm_(Handle, mat1.Handle, mat2.Handle, beta, alpha);
				CheckForErrors();
				return this;
			}

			public Tensor addmv(Tensor mat, Tensor vec, float beta = 1f, float alpha = 1f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_addmv(Handle, mat.Handle, vec.Handle, beta, alpha);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor addmv_(Tensor mat, Tensor vec, float beta = 1f, float alpha = 1f)
			{
				NativeMethods.THSTensor_addmv_(Handle, mat.Handle, vec.Handle, beta, alpha);
				CheckForErrors();
				return this;
			}

			public Tensor addr(Tensor vec1, Tensor vec2, float beta = 1f, float alpha = 1f)
			{
				IntPtr intPtr = NativeMethods.THSTensor_addr(Handle, vec1.Handle, vec2.Handle, beta, alpha);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor addr_(Tensor vec1, Tensor vec2, float beta = 1f, float alpha = 1f)
			{
				NativeMethods.THSTensor_addr_(Handle, vec1.Handle, vec2.Handle, beta, alpha);
				CheckForErrors();
				return this;
			}

			public Tensor bitwise_and(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bitwise_and(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bitwise_and_(Tensor other)
			{
				NativeMethods.THSTensor_bitwise_and_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor bitwise_not()
			{
				IntPtr intPtr = NativeMethods.THSTensor_bitwise_not(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bitwise_not_()
			{
				NativeMethods.THSTensor_bitwise_not_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor bitwise_or(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bitwise_or(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bitwise_or_(Tensor other)
			{
				NativeMethods.THSTensor_bitwise_or_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor bitwise_xor(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bitwise_xor(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bitwise_xor_(Tensor other)
			{
				NativeMethods.THSTensor_bitwise_xor_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor bitwise_left_shift(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bitwise_left_shift(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bitwise_left_shift_(Tensor other)
			{
				NativeMethods.THSTensor_bitwise_left_shift_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor bitwise_right_shift(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_bitwise_right_shift(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor bitwise_right_shift_(Tensor other)
			{
				NativeMethods.THSTensor_bitwise_right_shift_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor ceil()
			{
				IntPtr intPtr = NativeMethods.THSTensor_ceil(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor ceil_()
			{
				NativeMethods.THSTensor_ceil_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor conj()
			{
				IntPtr intPtr = NativeMethods.THSTensor_conj(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor conj_physical()
			{
				IntPtr intPtr = NativeMethods.THSTensor_conj_physical(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor conj_physical_()
			{
				NativeMethods.THSTensor_conj_physical_(Handle);
				CheckForErrors();
				return this;
			}

			public bool is_conj()
			{
				long num = NativeMethods.THSTensor_is_conj(Handle);
				if (num == -1)
				{
					CheckForErrors();
				}
				return num != 0;
			}

			public Tensor resolve_conj()
			{
				IntPtr intPtr = NativeMethods.THSTensor_resolve_conj(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public bool is_neg()
			{
				long num = NativeMethods.THSTensor_is_neg(Handle);
				if (num == -1)
				{
					CheckForErrors();
				}
				return num != 0;
			}

			public Tensor resolve_neg()
			{
				IntPtr intPtr = NativeMethods.THSTensor_resolve_neg(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public (Tensor values, Tensor indexes) cummax(long dim)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_cummax(Handle, pinnedArray.CreateArray, dim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return (values: new Tensor(array[0]), indexes: new Tensor(array[1]));
			}

			public (Tensor values, Tensor indexes) cummin(long dim)
			{
				IntPtr[] array;
				using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
				{
					NativeMethods.THSTensor_cummin(Handle, pinnedArray.CreateArray, dim);
					CheckForErrors();
					array = pinnedArray.Array;
				}
				return (values: new Tensor(array[0]), indexes: new Tensor(array[1]));
			}

			public Tensor cumsum(long dim, ScalarType? type = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cumsum(Handle, dim, type.HasValue, (sbyte)type.GetValueOrDefault());
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cumprod(long dim, ScalarType? type = null)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cumprod(Handle, dim, type.HasValue, (sbyte)type.GetValueOrDefault());
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor div(Tensor target, RoundingMode rounding_mode = RoundingMode.None)
			{
				IntPtr intPtr = NativeMethods.THSTensor_div(Handle, target.Handle, rounding_mode switch
				{
					RoundingMode.floor => "floor", 
					RoundingMode.trunc => "trunc", 
					_ => null, 
				});
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor divide(Tensor target, RoundingMode rounding_mode = RoundingMode.None)
			{
				return div(target, rounding_mode);
			}

			public Tensor div(Scalar target, RoundingMode rounding_mode = RoundingMode.None)
			{
				IntPtr intPtr = NativeMethods.THSTensor_div_scalar(Handle, target.Handle, rounding_mode switch
				{
					RoundingMode.floor => "floor", 
					RoundingMode.trunc => "trunc", 
					_ => null, 
				});
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor divide(Scalar target, RoundingMode rounding_mode = RoundingMode.None)
			{
				return div(target, rounding_mode);
			}

			public Tensor div_(Tensor target, RoundingMode rounding_mode = RoundingMode.None)
			{
				NativeMethods.THSTensor_div_(Handle, target.Handle, rounding_mode switch
				{
					RoundingMode.floor => "floor", 
					RoundingMode.trunc => "trunc", 
					_ => null, 
				});
				CheckForErrors();
				return this;
			}

			public Tensor divide_(Tensor target, RoundingMode rounding_mode = RoundingMode.None)
			{
				return div_(target, rounding_mode);
			}

			public Tensor div_(Scalar target, RoundingMode rounding_mode = RoundingMode.None)
			{
				NativeMethods.THSTensor_div_scalar_(Handle, target.Handle, rounding_mode switch
				{
					RoundingMode.floor => "floor", 
					RoundingMode.trunc => "trunc", 
					_ => null, 
				});
				CheckForErrors();
				return this;
			}

			public Tensor divide_(Scalar target, RoundingMode rounding_mode = RoundingMode.None)
			{
				return div_(target, rounding_mode);
			}

			public Tensor exp()
			{
				IntPtr intPtr = NativeMethods.THSTensor_exp(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor exp_()
			{
				NativeMethods.THSTensor_exp_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor exp2()
			{
				IntPtr intPtr = NativeMethods.THSTensor_exp2(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor expm1()
			{
				IntPtr intPtr = NativeMethods.THSTensor_expm1(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor expm1_()
			{
				NativeMethods.THSTensor_expm1_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor float_power(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_float_power(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor floor()
			{
				IntPtr intPtr = NativeMethods.THSTensor_floor(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor floor_()
			{
				NativeMethods.THSTensor_floor_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor floor_divide(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_floor_divide(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor floor_divide(Scalar other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_floor_divide_scalar(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor floor_divide_(Tensor other)
			{
				NativeMethods.THSTensor_floor_divide_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor floor_divide_(Scalar other)
			{
				NativeMethods.THSTensor_floor_divide_scalar_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor fmod(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_fmod(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor fmod_(Tensor target)
			{
				NativeMethods.THSTensor_fmod_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor fmod(Scalar scalar)
			{
				IntPtr intPtr = NativeMethods.THSTensor_fmod_scalar(Handle, scalar.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor fmod_(Scalar scalar)
			{
				NativeMethods.THSTensor_fmod_scalar_(Handle, scalar.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor frac()
			{
				IntPtr intPtr = NativeMethods.THSTensor_frac(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor frac_()
			{
				NativeMethods.THSTensor_frac_(Handle);
				CheckForErrors();
				return this;
			}

			public (Tensor Mantissa, Tensor Exponent) frexp()
			{
				IntPtr exponent;
				IntPtr intPtr = NativeMethods.THSTensor_frexp(Handle, out exponent);
				if (intPtr == IntPtr.Zero || exponent == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (Mantissa: new Tensor(intPtr), Exponent: new Tensor(exponent));
			}

			public Tensor gcd(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_gcd(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor gcd_(Tensor other)
			{
				NativeMethods.THSTensor_gcd_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor histc(long bins = 100L, long min = 0L, long max = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_histc(Handle, bins, min, max);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor hypot(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_hypot(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor log()
			{
				IntPtr intPtr = NativeMethods.THSTensor_log(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor log_()
			{
				NativeMethods.THSTensor_log_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor logaddexp(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logaddexp(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logaddexp2(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logaddexp2(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logcumsumexp(long dim)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logcumsumexp(Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logsumexp(long dim, bool keepdim = false)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logsumexp(Handle, dim, keepdim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor log_softmax(long dim, ScalarType? dtype = null)
			{
				return special.log_softmax(this, dim, dtype);
			}

			public Tensor log10()
			{
				IntPtr intPtr = NativeMethods.THSTensor_log10(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor log10_()
			{
				NativeMethods.THSTensor_log10_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor log1p()
			{
				IntPtr intPtr = NativeMethods.THSTensor_log1p(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor log1p_()
			{
				NativeMethods.THSTensor_log1p_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor log2()
			{
				IntPtr intPtr = NativeMethods.THSTensor_log2(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor log2_()
			{
				NativeMethods.THSTensor_log2_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor logical_and(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logical_and(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logical_and_(Tensor other)
			{
				NativeMethods.THSTensor_logical_and_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor logical_not()
			{
				IntPtr intPtr = NativeMethods.THSTensor_logical_not(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logical_not_()
			{
				NativeMethods.THSTensor_logical_not_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor logical_or(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logical_or(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logical_or_(Tensor other)
			{
				NativeMethods.THSTensor_logical_or_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor logical_xor(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_logical_xor(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor logical_xor_(Tensor other)
			{
				NativeMethods.THSTensor_logical_xor_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public unsafe Tensor logit(double? eps = null)
			{
				fixed (double* ptr = ((!eps.HasValue) ? null : new double[1] { eps.Value }))
				{
					IntPtr intPtr = NativeMethods.THSTensor_logit(Handle, (IntPtr)ptr);
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					return new Tensor(intPtr);
				}
			}

			public Tensor mul(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_mul(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor multiply(Tensor target)
			{
				return mul(target);
			}

			public Tensor mul(Scalar target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_mul_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor multiply(Scalar target)
			{
				return mul(target);
			}

			public Tensor mul_(Tensor target)
			{
				NativeMethods.THSTensor_mul_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor mul_(Scalar target)
			{
				NativeMethods.THSTensor_mul_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public static Tensor operator -(Tensor tensor)
			{
				return tensor.neg();
			}

			public Tensor neg()
			{
				IntPtr intPtr = NativeMethods.THSTensor_neg(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor negative()
			{
				return neg();
			}

			public Tensor neg_()
			{
				NativeMethods.THSTensor_neg_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor pow(Tensor exponent)
			{
				IntPtr intPtr = NativeMethods.THSTensor_pow(Handle, exponent.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor pow_(Tensor exponent)
			{
				NativeMethods.THSTensor_pow_(Handle, exponent.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor pow(Scalar exponent)
			{
				IntPtr intPtr = NativeMethods.THSTensor_pow_scalar(Handle, exponent.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor pow_(Scalar exponent)
			{
				NativeMethods.THSTensor_pow_scalar_(Handle, exponent.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor reciprocal()
			{
				IntPtr intPtr = NativeMethods.THSTensor_reciprocal(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor reciprocal_()
			{
				NativeMethods.THSTensor_reciprocal_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor remainder(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_remainder(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor remainder_(Tensor target)
			{
				NativeMethods.THSTensor_remainder_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor remainder(Scalar scalar)
			{
				IntPtr intPtr = NativeMethods.THSTensor_remainder_scalar(Handle, scalar.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor remainder_(Scalar scalar)
			{
				NativeMethods.THSTensor_remainder_scalar_(Handle, scalar.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor round(long decimals = 0L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_round(Handle, decimals);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor round_(long decimals = 0L)
			{
				NativeMethods.THSTensor_round_(Handle, decimals);
				CheckForErrors();
				return this;
			}

			public Tensor rsqrt()
			{
				IntPtr intPtr = NativeMethods.THSTensor_rsqrt(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor rsqrt_()
			{
				NativeMethods.THSTensor_rsqrt_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor square()
			{
				return pow(2);
			}

			public Tensor sqrt()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sqrt(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sqrt_()
			{
				NativeMethods.THSTensor_sqrt_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor sign()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sign(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sign_()
			{
				NativeMethods.THSTensor_sign_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor sgn()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sgn(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sgn_()
			{
				NativeMethods.THSTensor_sgn_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor signbit()
			{
				IntPtr intPtr = NativeMethods.THSTensor_signbit(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sub(Tensor target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_sub(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sub(Scalar target)
			{
				IntPtr intPtr = NativeMethods.THSTensor_sub_scalar(Handle, target.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor subtract(Scalar target)
			{
				return sub(target);
			}

			public Tensor subtract(Tensor target)
			{
				return sub(target);
			}

			public Tensor subtract_(Scalar target)
			{
				return sub_(target);
			}

			public Tensor subtract_(Tensor target)
			{
				return sub_(target);
			}

			public Tensor sub_(Tensor target)
			{
				NativeMethods.THSTensor_sub_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor sub_(Scalar target)
			{
				NativeMethods.THSTensor_sub_scalar_(Handle, target.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor cumulative_trapezoid(double dx = 1.0, long dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cumulative_trapezoid_dx(Handle, dx, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cumulative_trapezoid(Tensor x, long dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_cumulative_trapezoid_x(Handle, x.Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor trapezoid(double dx = 1.0, long dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_trapezoid_dx(Handle, dx, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor trapezoid(Tensor x, long dim = -1L)
			{
				IntPtr intPtr = NativeMethods.THSTensor_trapezoid_x(Handle, x.Handle, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor true_divide(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_true_divide(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor true_divide(Scalar other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_true_divide_scalar(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor true_divide_(Tensor other)
			{
				NativeMethods.THSTensor_true_divide_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor true_divide_(Scalar other)
			{
				NativeMethods.THSTensor_true_divide_scalar_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor trunc()
			{
				IntPtr intPtr = NativeMethods.THSTensor_trunc(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor fix()
			{
				return trunc();
			}

			public Tensor trunc_()
			{
				NativeMethods.THSTensor_trunc_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor fix_()
			{
				return trunc_();
			}

			public Tensor xlogy(Tensor y)
			{
				IntPtr intPtr = NativeMethods.THSTensor_xlogy(Handle, y.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor xlogy_(Tensor y)
			{
				NativeMethods.THSTensor_xlogy_(Handle, y.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor xlogy(Scalar y)
			{
				IntPtr intPtr = NativeMethods.THSTensor_xlogy_scalar(Handle, y.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor xlogy_(Scalar y)
			{
				NativeMethods.THSTensor_xlogy_scalar_(Handle, y.Handle);
				CheckForErrors();
				return this;
			}

			public static Tensor operator +(Tensor left, Tensor right)
			{
				return left.add(right);
			}

			public static Tensor operator +(Tensor left, Scalar right)
			{
				return left.add(right);
			}

			public static Tensor operator +(Scalar left, Tensor right)
			{
				return right.add(left);
			}

			public static Tensor operator +(Tensor left, int right)
			{
				return left.add(right);
			}

			public static Tensor operator +(Tensor left, long right)
			{
				return left.add(right);
			}

			public static Tensor operator +(Tensor left, float right)
			{
				return left.add(right);
			}

			public static Tensor operator +(Tensor left, double right)
			{
				return left.add(right);
			}

			public static Tensor operator +(int left, Tensor right)
			{
				return right.add(left);
			}

			public static Tensor operator +(long left, Tensor right)
			{
				return right.add(left);
			}

			public static Tensor operator +(float left, Tensor right)
			{
				return right.add(left);
			}

			public static Tensor operator +(double left, Tensor right)
			{
				return right.add(left);
			}

			public static Tensor operator *(Tensor left, Tensor right)
			{
				return left.mul(right);
			}

			public static Tensor operator *(Tensor left, Scalar right)
			{
				return left.mul(right);
			}

			public static Tensor operator *(Scalar left, Tensor right)
			{
				return right.mul(left);
			}

			public static Tensor operator *(Tensor left, int right)
			{
				return left.mul(right);
			}

			public static Tensor operator *(Tensor left, long right)
			{
				return left.mul(right);
			}

			public static Tensor operator *(Tensor left, float right)
			{
				return left.mul(right);
			}

			public static Tensor operator *(Tensor left, double right)
			{
				return left.mul(right);
			}

			public static Tensor operator *(int left, Tensor right)
			{
				return right.mul(left);
			}

			public static Tensor operator *(long left, Tensor right)
			{
				return right.mul(left);
			}

			public static Tensor operator *(float left, Tensor right)
			{
				return right.mul(left);
			}

			public static Tensor operator *(double left, Tensor right)
			{
				return right.mul(left);
			}

			public static Tensor operator -(Tensor left, Tensor right)
			{
				return left.sub(right);
			}

			public static Tensor operator -(Tensor left, Scalar right)
			{
				return left.sub(right);
			}

			public static Tensor operator -(Scalar left, Tensor right)
			{
				return right.negative().add(left);
			}

			public static Tensor operator -(Tensor left, int right)
			{
				return left.sub(right);
			}

			public static Tensor operator -(Tensor left, long right)
			{
				return left.sub(right);
			}

			public static Tensor operator -(Tensor left, float right)
			{
				return left.sub(right);
			}

			public static Tensor operator -(Tensor left, double right)
			{
				return left.sub(right);
			}

			public static Tensor operator -(int left, Tensor right)
			{
				return right.negative().add(left);
			}

			public static Tensor operator -(long left, Tensor right)
			{
				return right.negative().add(left);
			}

			public static Tensor operator -(float left, Tensor right)
			{
				return right.negative().add(left);
			}

			public static Tensor operator -(double left, Tensor right)
			{
				return right.negative().add(left);
			}

			public static Tensor operator /(Tensor left, Tensor right)
			{
				return left.div(right);
			}

			public static Tensor operator /(Tensor left, Scalar right)
			{
				return left.div(right);
			}

			public static Tensor operator /(Scalar left, Tensor right)
			{
				return right.reciprocal().mul(left);
			}

			public static Tensor operator /(Tensor left, int right)
			{
				return left.div(right);
			}

			public static Tensor operator /(Tensor left, long right)
			{
				return left.div(right);
			}

			public static Tensor operator /(Tensor left, float right)
			{
				return left.div(right);
			}

			public static Tensor operator /(Tensor left, double right)
			{
				return left.div(right);
			}

			public static Tensor operator /(int left, Tensor right)
			{
				return right.reciprocal().mul(left);
			}

			public static Tensor operator /(long left, Tensor right)
			{
				return right.reciprocal().mul(left);
			}

			public static Tensor operator /(float left, Tensor right)
			{
				return right.reciprocal().mul(left);
			}

			public static Tensor operator /(double left, Tensor right)
			{
				return right.reciprocal().mul(left);
			}

			public static Tensor operator %(Tensor left, Tensor right)
			{
				return left.remainder(right);
			}

			public static Tensor operator %(Tensor left, Scalar right)
			{
				return left.remainder(right);
			}

			public static Tensor operator %(Tensor left, int right)
			{
				return left.remainder(right);
			}

			public static Tensor operator %(Tensor left, long right)
			{
				return left.remainder(right);
			}

			public static Tensor operator %(Tensor left, float right)
			{
				return left.remainder(right);
			}

			public static Tensor operator %(Tensor left, double right)
			{
				return left.remainder(right);
			}

			public static Tensor operator &(Tensor left, Tensor right)
			{
				return left.bitwise_and(right);
			}

			public static Tensor operator |(Tensor left, Tensor right)
			{
				return left.bitwise_or(right);
			}

			public static Tensor operator ^(Tensor left, Tensor right)
			{
				return left.bitwise_xor(right);
			}

			public static Tensor operator ~(Tensor left)
			{
				return left.bitwise_not();
			}

			public Tensor angle()
			{
				IntPtr intPtr = NativeMethods.THSTensor_angle(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor asin()
			{
				IntPtr intPtr = NativeMethods.THSTensor_asin(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor arcsin()
			{
				return asin();
			}

			public Tensor asin_()
			{
				NativeMethods.THSTensor_asin_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor arcsin_()
			{
				return asin_();
			}

			public Tensor acos()
			{
				IntPtr intPtr = NativeMethods.THSTensor_acos(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor arccos()
			{
				return acos();
			}

			public Tensor acos_()
			{
				NativeMethods.THSTensor_acos_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor arccos_()
			{
				return acos_();
			}

			public Tensor atan()
			{
				IntPtr intPtr = NativeMethods.THSTensor_atan(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor arctan()
			{
				return atan();
			}

			public Tensor arctan(Tensor other)
			{
				return atan2(other);
			}

			public Tensor arctan_(Tensor other)
			{
				return atan2_(other);
			}

			public Tensor atan_()
			{
				NativeMethods.THSTensor_atan_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor arctan_()
			{
				return atan_();
			}

			public Tensor atan2(Tensor other)
			{
				IntPtr intPtr = NativeMethods.THSTensor_atan2(Handle, other.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor arctan2_(Tensor other)
			{
				return atan2_(other);
			}

			public Tensor arctan2(Tensor other)
			{
				return atan2(other);
			}

			public Tensor atan2_(Tensor other)
			{
				NativeMethods.THSTensor_atan2_(Handle, other.Handle);
				CheckForErrors();
				return this;
			}

			public Tensor cos()
			{
				IntPtr intPtr = NativeMethods.THSTensor_cos(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cos_()
			{
				NativeMethods.THSTensor_cos_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor sin()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sin(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sin_()
			{
				NativeMethods.THSTensor_sin_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor tan()
			{
				IntPtr intPtr = NativeMethods.THSTensor_tan(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor tan_()
			{
				NativeMethods.THSTensor_tan_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor sinc()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sinc(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sinc_()
			{
				NativeMethods.THSTensor_sinc_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor sinh()
			{
				IntPtr intPtr = NativeMethods.THSTensor_sinh(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor sinh_()
			{
				NativeMethods.THSTensor_sinh_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor cosh()
			{
				IntPtr intPtr = NativeMethods.THSTensor_cosh(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor cosh_()
			{
				NativeMethods.THSTensor_cosh_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor tanh()
			{
				IntPtr intPtr = NativeMethods.THSTensor_tanh(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor tanh_()
			{
				NativeMethods.THSTensor_tanh_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor arcsinh()
			{
				IntPtr intPtr = NativeMethods.THSTensor_arcsinh(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor asinh()
			{
				return arcsinh();
			}

			public Tensor arcsinh_()
			{
				NativeMethods.THSTensor_arcsinh_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor asinh_()
			{
				return arcsinh_();
			}

			public Tensor arccosh()
			{
				IntPtr intPtr = NativeMethods.THSTensor_arccosh(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor acosh()
			{
				return arccosh();
			}

			public Tensor arccosh_()
			{
				NativeMethods.THSTensor_arccosh_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor acosh_()
			{
				return arccosh_();
			}

			public Tensor arctanh()
			{
				IntPtr intPtr = NativeMethods.THSTensor_arctanh(Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public Tensor atanh()
			{
				return arctanh();
			}

			public Tensor arctanh_()
			{
				NativeMethods.THSTensor_arctanh_(Handle);
				CheckForErrors();
				return this;
			}

			public Tensor atanh_()
			{
				return arctanh_();
			}
		}

		public struct Size : IEnumerable<long>, IEnumerable
		{
			public static Size Empty = new Size(Array.Empty<long>());

			private long[] _shape;

			public bool IsEmpty => _shape.Length == 0;

			public bool IsScalar => IsEmpty;

			public int Length => _shape.Length;

			public long this[int idx] => _shape[idx];

			public long this[long idx] => _shape[(int)idx];

			public long[] Shape => _shape;

			public Size(long[] shape)
			{
				_shape = (long[])shape.Clone();
			}

			public Size(IEnumerable<long> shape)
			{
				_shape = shape.ToArray();
			}

			public Size(int[] shape)
			{
				_shape = ((IEnumerable<int>)shape).Select((Func<int, long>)((int i) => i)).ToArray();
			}

			public Size(long size)
			{
				_shape = new long[1] { size };
			}

			public Size((long, long) size)
			{
				_shape = new long[2] { size.Item1, size.Item2 };
			}

			public Size((long, long, long) size)
			{
				_shape = new long[3] { size.Item1, size.Item2, size.Item3 };
			}

			public Size((long, long, long, long) size)
			{
				_shape = new long[4] { size.Item1, size.Item2, size.Item3, size.Item4 };
			}

			public Size((long, long, long, long, long) size)
			{
				_shape = new long[5] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5 };
			}

			public Size((long, long, long, long, long, long) size)
			{
				_shape = new long[6] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5, size.Item6 };
			}

			public Size(int size)
			{
				_shape = new long[1] { size };
			}

			public Size((int, int) size)
			{
				_shape = new long[2] { size.Item1, size.Item2 };
			}

			public Size((int, int, int) size)
			{
				_shape = new long[3] { size.Item1, size.Item2, size.Item3 };
			}

			public Size((int, int, int, int) size)
			{
				_shape = new long[4] { size.Item1, size.Item2, size.Item3, size.Item4 };
			}

			public Size((int, int, int, int, int) size)
			{
				_shape = new long[5] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5 };
			}

			public Size((int, int, int, int, int, int) size)
			{
				_shape = new long[6] { size.Item1, size.Item2, size.Item3, size.Item4, size.Item5, size.Item6 };
			}

			public static implicit operator Size(long size)
			{
				return new Size(size);
			}

			public static implicit operator Size((long, long) size)
			{
				return new Size(size);
			}

			public static implicit operator Size((long, long, long) size)
			{
				return new Size(size);
			}

			public static implicit operator Size((long, long, long, long) size)
			{
				return new Size(size);
			}

			public static implicit operator Size((long, long, long, long, long) size)
			{
				return new Size(size);
			}

			public static implicit operator Size((long, long, long, long, long, long) size)
			{
				return new Size(size);
			}

			public static implicit operator Size(long[] size)
			{
				return new Size(size);
			}

			public static Size operator +(Size left, Size right)
			{
				return new Size(left._shape.AsEnumerable().Concat(right._shape).ToArray());
			}

			public static Size operator +(Size left, IEnumerable<long> right)
			{
				return new Size(left._shape.AsEnumerable().Concat(right).ToArray());
			}

			public static bool operator ==(Size left, Size right)
			{
				return left._shape == right._shape;
			}

			public static bool operator !=(Size left, Size right)
			{
				return left._shape != right._shape;
			}

			public override bool Equals(object? obj)
			{
				if (obj == null || !(obj is Size))
				{
					return false;
				}
				return _shape.Equals(((Size)obj)._shape);
			}

			public Size Slice(int first, int next)
			{
				if (next < 0)
				{
					next = _shape.Length + next;
				}
				if (first < 0)
				{
					first = _shape.Length + first;
				}
				if (next <= first)
				{
					return Empty;
				}
				if (first == 0)
				{
					if (next == _shape.Length)
					{
						return this;
					}
					return new Size(_shape.Take(next));
				}
				if (next == _shape.Length)
				{
					return new Size(_shape.Skip(first));
				}
				return new Size(_shape.Skip(first).Take(next - first));
			}

			public override int GetHashCode()
			{
				return _shape.GetHashCode();
			}

			public long numel()
			{
				long num = 1L;
				long[] shape = _shape;
				foreach (long num2 in shape)
				{
					num *= num2;
				}
				return num;
			}

			public IEnumerable<long> Take(int i)
			{
				return _shape.Take(i);
			}

			public IEnumerator<long> GetEnumerator()
			{
				return _shape.AsEnumerable().GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		public abstract class Storage
		{
			protected Tensor _tensor;

			protected IntPtr _tensor_data_ptr;

			protected Storage()
			{
			}

			protected Storage(Tensor tensor)
			{
				_tensor = tensor;
				data_ptr();
			}

			protected Storage(Tensor tensor, IntPtr data_ptr)
			{
				_tensor = tensor;
				_tensor_data_ptr = ((data_ptr == IntPtr.Zero) ? this.data_ptr() : data_ptr);
			}

			internal static Storage<T> Create<T>(Tensor tensor) where T : unmanaged
			{
				Type typeFromHandle = typeof(T);
				if ((object)typeFromHandle != null)
				{
					if (typeFromHandle == typeof(byte))
					{
						return new Storage<T>(tensor.@byte());
					}
					if (typeFromHandle == typeof(bool))
					{
						return new Storage<T>(tensor.@bool());
					}
					if (typeFromHandle == typeof(int))
					{
						return new Storage<T>(tensor.@int());
					}
					if (typeFromHandle == typeof(long))
					{
						return new Storage<T>(tensor.@long());
					}
					if (typeFromHandle == typeof(float))
					{
						return new Storage<T>(tensor.@float());
					}
					if (typeFromHandle == typeof(double))
					{
						return new Storage<T>(tensor.@double());
					}
					if (typeFromHandle == typeof((float, float)))
					{
						return new Storage<T>(tensor.to_type(ScalarType.ComplexFloat32));
					}
					if (typeFromHandle == typeof(Complex))
					{
						return new Storage<T>(tensor.to_type(ScalarType.ComplexFloat64));
					}
				}
				throw new NotSupportedException();
			}

			protected static Tensor CreateTypedTensor<T>(ScalarType dtype, IList<T> rawArray)
			{
				return dtype switch
				{
					ScalarType.Int8 => tensor(rawArray as IList<byte>), 
					ScalarType.Bool => tensor(rawArray as IList<bool>), 
					ScalarType.Int32 => tensor(rawArray as IList<int>), 
					ScalarType.Int64 => tensor(rawArray as IList<long>), 
					ScalarType.Float32 => tensor(rawArray as IList<float>), 
					ScalarType.Float64 => tensor(rawArray as IList<double>), 
					ScalarType.ComplexFloat32 => tensor(rawArray as IList<(float, float)>), 
					ScalarType.ComplexFloat64 => tensor(rawArray as IList<Complex>), 
					_ => throw new NotSupportedException(), 
				};
			}

			public Storage<bool> @bool()
			{
				return _tensor.to_type(ScalarType.Bool).storage<bool>();
			}

			public Storage<byte> @byte()
			{
				return _tensor.to_type(ScalarType.Byte).storage<byte>();
			}

			public Storage<char> @char()
			{
				return _tensor.to_type(ScalarType.Int8).storage<char>();
			}

			public Storage<int> @int()
			{
				return _tensor.to_type(ScalarType.Int32).storage<int>();
			}

			public Storage<long> @long()
			{
				return _tensor.to_type(ScalarType.Int64).storage<long>();
			}

			public Storage<float> @float()
			{
				return _tensor.to_type(ScalarType.Float32).storage<float>();
			}

			public Storage<double> @double()
			{
				return _tensor.to_type(ScalarType.Float64).storage<double>();
			}

			public Storage<(float, float)> complex_float()
			{
				return _tensor.to_type(ScalarType.ComplexFloat32).storage<(float, float)>();
			}

			public Storage<Complex> complex_double()
			{
				return _tensor.to_type(ScalarType.ComplexFloat64).storage<Complex>();
			}

			public abstract int element_size();

			protected IntPtr data_ptr()
			{
				if (_tensor_data_ptr != IntPtr.Zero)
				{
					return _tensor_data_ptr;
				}
				IntPtr intPtr = NativeMethods.THSStorage_data_ptr(_tensor.Handle);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				_tensor_data_ptr = intPtr;
				return intPtr;
			}

			public ulong nbytes()
			{
				ulong result = NativeMethods.THSStorage_nbytes(_tensor.Handle);
				CheckForErrors();
				return result;
			}
		}

		public sealed class Storage<T> : Storage, IDisposable, IEnumerable<T>, IEnumerable where T : unmanaged
		{
			private struct StorageEnumerator : IEnumerator<T>, IEnumerator, IDisposable
			{
				private Storage<T> _span;

				private readonly long _count;

				private long _index;

				private T _current;

				public T Current => _current;

				object IEnumerator.Current => Current;

				public StorageEnumerator(Storage<T> span)
				{
					_span = span;
					_count = span.Count;
					_index = -1L;
					_current = default(T);
				}

				public void Dispose()
				{
					_span = null;
					Reset();
				}

				public unsafe bool MoveNext()
				{
					if (_index >= _count - 1)
					{
						Reset();
						return false;
					}
					_index++;
					_current = ((T*)(void*)_span._tensor_data_ptr)[_index];
					return true;
				}

				public void Reset()
				{
					_index = -1L;
					_current = default(T);
				}
			}

			private T _scalarValue;

			private int _count = -1;

			public Device device
			{
				get
				{
					ValidateNotScalar();
					return _tensor.device;
				}
			}

			public unsafe T this[int index]
			{
				get
				{
					ValidateNotScalar();
					CheckIndex(index);
					T* ptr = (T*)(void*)_tensor_data_ptr;
					return ptr[index];
				}
				set
				{
					ValidateNotScalar();
					CheckIndex(index);
					T* ptr = (T*)(void*)_tensor_data_ptr;
					ptr[index] = value;
				}
			}

			public unsafe Storage<T> this[(int? start, int? end) range]
			{
				get
				{
					ValidateNotScalar();
					if (range.end < range.start)
					{
						throw new ArgumentException("end < start");
					}
					int num = CheckIndex(range.start.HasValue ? range.start.Value : 0);
					int count = CheckIndex(range.end.HasValue ? range.end.Value : Count) - num;
					return new Storage<T>(_tensor_data_ptr + sizeof(T) * num, _tensor.dtype, count);
				}
				set
				{
					ValidateNotScalar();
					if ((object)value._tensor != null || value._tensor_data_ptr != IntPtr.Zero)
					{
						throw new InvalidOperationException();
					}
					if (range.end < range.start)
					{
						throw new ArgumentException("end < start");
					}
					T scalarValue = value._scalarValue;
					int num = CheckIndex(range.start.HasValue ? range.start.Value : 0);
					int num2 = CheckIndex(range.end.HasValue ? range.end.Value : Count);
					T* ptr = (T*)(void*)_tensor_data_ptr;
					for (int i = num; i < num2; i++)
					{
						ptr[i] = scalarValue;
					}
				}
			}

			public unsafe int Count
			{
				get
				{
					ValidateNotScalar();
					if (_count == -1)
					{
						_count = (int)nbytes() / sizeof(T);
					}
					return _count;
				}
			}

			public bool IsReadOnly => false;

			internal Storage(Tensor tensor, int count = -1)
				: base(tensor, IntPtr.Zero)
			{
				_count = count;
			}

			internal Storage(IntPtr data_ptr, ScalarType dtype, int count = -1)
				: base(null, data_ptr)
			{
				_count = count;
				_tensor = Storage.CreateTypedTensor(dtype, ToArray());
			}

			internal Storage(T value)
			{
				_scalarValue = value;
			}

			public unsafe override int element_size()
			{
				ValidateNotScalar();
				return sizeof(T);
			}

			public Storage<T> cuda(Device device = null)
			{
				ValidateNotScalar();
				return _tensor.cuda(device).storage<T>();
			}

			public Storage<T> cpu()
			{
				ValidateNotScalar();
				return _tensor.cpu().storage<T>();
			}

			public T[] ToArray()
			{
				ValidateNotScalar();
				T[] array = new T[Count];
				CopyTo(array, 0);
				return array;
			}

			private int CheckIndex(int index)
			{
				if (index < 0 || index >= Count)
				{
					throw new IndexOutOfRangeException();
				}
				return index;
			}

			private void ValidateNotScalar()
			{
				if ((object)_tensor == null && _tensor_data_ptr == IntPtr.Zero)
				{
					throw new InvalidOperationException("Invalid use of a scalar Storage instance.");
				}
			}

			public static implicit operator Storage<T>(T value)
			{
				return new Storage<T>(value);
			}

			public void copy_(IList<T> array)
			{
				ValidateNotScalar();
				CopyFrom(array, 0);
			}

			public unsafe void fill_(T value)
			{
				ValidateNotScalar();
				T* ptr = (T*)(void*)data_ptr();
				for (int i = 0; i < Count; i++)
				{
					ptr[i] = value;
				}
			}

			public IList<T> tolist()
			{
				ValidateNotScalar();
				T[] array = new T[Count];
				CopyTo(array, 0);
				return array;
			}

			public unsafe bool Contains(T item)
			{
				ValidateNotScalar();
				T* ptr = (T*)(void*)data_ptr();
				for (int i = 0; i < Count; i++)
				{
					if (ptr[i].Equals(item))
					{
						return true;
					}
				}
				return false;
			}

			public unsafe void CopyTo(IList<T> array, int arrayIndex)
			{
				ValidateNotScalar();
				T* ptr = (T*)(void*)data_ptr();
				for (int i = 0; i < Count && i < array.Count - arrayIndex; i++)
				{
					array[i + arrayIndex] = ptr[i];
				}
			}

			public unsafe void CopyFrom(IList<T> array, int arrayIndex)
			{
				ValidateNotScalar();
				T* ptr = (T*)(void*)data_ptr();
				for (int i = 0; i < Count && i < array.Count - arrayIndex; i++)
				{
					ptr[i] = array[i + arrayIndex];
				}
			}

			public unsafe int IndexOf(T item)
			{
				T* ptr = (T*)(void*)data_ptr();
				for (int i = 0; i < Count; i++)
				{
					if (ptr[i].Equals(item))
					{
						return i;
					}
				}
				return -1;
			}

			public IEnumerator<T> GetEnumerator()
			{
				ValidateNotScalar();
				return new StorageEnumerator(this);
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				ValidateNotScalar();
				return new StorageEnumerator(this);
			}

			public void Dispose()
			{
				_tensor_data_ptr = IntPtr.Zero;
				_tensor = null;
			}
		}

		public struct TensorIndex
		{
			internal enum Kind
			{
				None,
				Single,
				Null,
				Ellipsis,
				Bool,
				Tensor,
				Slice
			}

			internal long? startIndexOrBoolOrSingle;

			internal long? stopIndex;

			internal long? step;

			internal Kind kind;

			internal Tensor? tensor;

			public static TensorIndex Ellipsis = new TensorIndex
			{
				kind = Kind.Ellipsis
			};

			public static TensorIndex None = new TensorIndex
			{
				kind = Kind.None
			};

			public static TensorIndex Null = new TensorIndex
			{
				kind = Kind.Null
			};

			public static TensorIndex Colon = Slice();

			public static TensorIndex Slice(long? start = null, long? stop = null, long? step = null)
			{
				return new TensorIndex
				{
					startIndexOrBoolOrSingle = start,
					step = step,
					stopIndex = stop,
					kind = Kind.Slice
				};
			}

			public static TensorIndex Slice((int? start, int? end) range)
			{
				return Slice(range.start, range.end);
			}

			public static TensorIndex Bool(bool value)
			{
				return new TensorIndex
				{
					startIndexOrBoolOrSingle = (value ? 1 : 0),
					kind = Kind.Bool
				};
			}

			public static TensorIndex Single(long? index)
			{
				return new TensorIndex
				{
					startIndexOrBoolOrSingle = index,
					kind = Kind.Single
				};
			}

			public static TensorIndex Tensor(Tensor tensor)
			{
				return new TensorIndex
				{
					tensor = tensor,
					kind = Kind.Tensor
				};
			}

			public static implicit operator TensorIndex(long value)
			{
				return Single(value);
			}

			public static implicit operator Tensor(TensorIndex value)
			{
				_throw();
				return new Tensor(IntPtr.Zero);
			}

			private static void _throw()
			{
				throw new InvalidOperationException("Should not be called.");
			}

			public static implicit operator TensorIndex((int? start, int? end) range)
			{
				return Slice(range.start, range.end);
			}
		}

		public enum ScalarType : sbyte
		{
			Byte = 0,
			Int8 = 1,
			Int16 = 2,
			Int32 = 3,
			Int64 = 4,
			Float16 = 5,
			Float32 = 6,
			Float64 = 7,
			ComplexFloat32 = 9,
			ComplexFloat64 = 10,
			Bool = 11,
			BFloat16 = 15
		}

		public struct FInfo
		{
			public int bits;

			public double eps;

			public double max;

			public double min;

			public double tiny;

			public double smallest_normal;

			public double resolution;
		}

		public enum RoundingMode
		{
			None,
			trunc,
			floor
		}

		internal class ComplexFloat32Tensor
		{
			public static Tensor arange(Scalar start, Scalar stop, Scalar step, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_arange(start.Handle, stop.Handle, step.Handle, 6, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_arange(start.Handle, stop.Handle, step.Handle, 6, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				IntPtr intPtr2 = NativeMethods.THSTensor_to_type(intPtr, 9, copy: false, non_blocking: false);
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr2);
			}

			public static Tensor from((float Real, float Imaginary) scalar, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat32Scalar(scalar.Real, scalar.Imaginary, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor from(float real, float imaginary = 0f, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat32Scalar(real, imaginary, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor randint(long low, long high, long[] size, Device device = null, bool requires_grad = false, Generator generator = null)
			{
				device = InitializeDevice(device);
				List<long> list = new List<long>();
				list.AddRange(size);
				list.Add(2L);
				long[] array = list.ToArray();
				IntPtr generator2 = generator?.Handle ?? IntPtr.Zero;
				fixed (long* ptr = array)
				{
					IntPtr intPtr = NativeMethods.THSTensor_randint(generator2, low, high, (IntPtr)ptr, array.Length, 6, (int)device.type, device.index, requires_grad);
					if (intPtr == IntPtr.Zero)
					{
						GC.Collect();
						GC.WaitForPendingFinalizers();
						intPtr = NativeMethods.THSTensor_randint(generator2, low, high, (IntPtr)ptr, array.Length, 6, (int)device.type, device.index, requires_grad);
					}
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					IntPtr intPtr2 = NativeMethods.THSTensor_view_as_complex(intPtr);
					if (intPtr2 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					IntPtr intPtr3 = NativeMethods.THSTensor_empty((IntPtr)ptr, size.Length, 9, (int)device.type, device.index, requires_grad);
					if (intPtr3 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					NativeMethods.THSTensor_copy_(intPtr3, intPtr2, non_blocking: false);
					CheckForErrors();
					NativeMethods.THSTensor_dispose(intPtr);
					NativeMethods.THSTensor_dispose(intPtr2);
					return new Tensor(intPtr3);
				}
			}
		}

		internal class ComplexFloat64Tensor
		{
			public static Tensor arange(Scalar start, Scalar stop, Scalar step, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_arange(start.Handle, stop.Handle, step.Handle, 7, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_arange(start.Handle, stop.Handle, step.Handle, 7, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				IntPtr intPtr2 = NativeMethods.THSTensor_to_type(intPtr, 10, copy: false, non_blocking: false);
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr2);
			}

			public static Tensor from(Complex scalar, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat64Scalar(scalar.Real, scalar.Imaginary, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public static Tensor from(double real, double imaginary = 0.0, Device device = null, bool requires_grad = false)
			{
				device = InitializeDevice(device);
				IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat64Scalar(real, imaginary, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}

			public unsafe static Tensor randint(long low, long high, long[] size, Device device = null, bool requires_grad = false, Generator generator = null)
			{
				device = InitializeDevice(device);
				List<long> list = new List<long>();
				list.AddRange(size);
				list.Add(2L);
				long[] array = list.ToArray();
				IntPtr generator2 = generator?.Handle ?? IntPtr.Zero;
				fixed (long* ptr = array)
				{
					IntPtr intPtr = NativeMethods.THSTensor_randint(generator2, low, high, (IntPtr)ptr, array.Length, 7, (int)device.type, device.index, requires_grad);
					if (intPtr == IntPtr.Zero)
					{
						GC.Collect();
						GC.WaitForPendingFinalizers();
						intPtr = NativeMethods.THSTensor_randint(generator2, low, high, (IntPtr)ptr, array.Length, 7, (int)device.type, device.index, requires_grad);
					}
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					IntPtr intPtr2 = NativeMethods.THSTensor_view_as_complex(intPtr);
					if (intPtr2 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					IntPtr intPtr3 = NativeMethods.THSTensor_empty((IntPtr)ptr, size.Length, 10, (int)device.type, device.index, requires_grad);
					if (intPtr3 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					NativeMethods.THSTensor_copy_(intPtr3, intPtr2, non_blocking: false);
					CheckForErrors();
					NativeMethods.THSTensor_dispose(intPtr);
					NativeMethods.THSTensor_dispose(intPtr2);
					return new Tensor(intPtr3);
				}
			}
		}

		public enum LobpcgMethod
		{
			basic,
			ortho
		}

		public static class random
		{
			public static long seed()
			{
				return Generator.Default.seed();
			}

			public static long initial_seed()
			{
				return Generator.Default.initial_seed();
			}

			public static Generator manual_seed(long seed)
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				IntPtr intPtr = NativeMethods.THSGenerator_manual_seed(seed);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Generator(intPtr);
			}

			public static Tensor get_rng_state()
			{
				return Generator.Default.get_state();
			}

			public static void set_rng_state(Tensor new_state)
			{
				Generator.Default.set_state(new_state);
			}
		}

		public static class cuda
		{
			[MethodImpl(MethodImplOptions.NoInlining)]
			internal static bool CallTorchCudaIsAvailable()
			{
				return NativeMethods.THSTorchCuda_is_available();
			}

			public static bool is_available()
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				return CallTorchCudaIsAvailable();
			}

			public static bool is_cudnn_available()
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				return NativeMethods.THSTorchCuda_cudnn_is_available();
			}

			public static int device_count()
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				return NativeMethods.THSTorchCuda_device_count();
			}

			public static void manual_seed(long seed)
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				NativeMethods.THSCuda_manual_seed(seed);
			}

			public static void manual_seed_all(long seed)
			{
				TryInitializeDeviceType(DeviceType.CUDA);
				NativeMethods.THSCuda_manual_seed_all(seed);
			}

			public static void synchronize(Device? device = null)
			{
				TryInitializeDeviceType(device?.type ?? DeviceType.CUDA);
				NativeMethods.THSTorchCuda_synchronize(device?.index ?? (-1));
			}
		}

		public static class backends
		{
			public static class cuda
			{
				public static class matmul
				{
					public static bool allow_tf32
					{
						get
						{
							bool result = NativeMethods.THSBackend_cublas_get_allow_tf32();
							CheckForErrors();
							return result;
						}
						set
						{
							NativeMethods.THSBackend_cublas_set_allow_tf32(value);
							CheckForErrors();
						}
					}

					public static bool allow_fp16_reduced_precision_reduction
					{
						get
						{
							bool result = NativeMethods.THSBackend_cuda_get_allow_fp16_reduced_precision_reduction();
							CheckForErrors();
							return result;
						}
						set
						{
							NativeMethods.THSBackend_cuda_set_allow_fp16_reduced_precision_reduction(value);
							CheckForErrors();
						}
					}
				}

				public static bool flash_sdp_enabled()
				{
					bool result = NativeMethods.THSBackend_cuda_get_enable_flash_sdp();
					CheckForErrors();
					return result;
				}

				public static void enable_flash_sdp(bool enable)
				{
					NativeMethods.THSBackend_cuda_set_enable_flash_sdp(enable);
					CheckForErrors();
				}

				public static bool math_sdp_enabled()
				{
					bool result = NativeMethods.THSBackend_cuda_get_enable_math_sdp();
					CheckForErrors();
					return result;
				}

				public static void enable_math_sdp(bool enable)
				{
					NativeMethods.THSBackend_cuda_set_enable_math_sdp(enable);
					CheckForErrors();
				}
			}

			public static class cudnn
			{
				public static bool allow_tf32
				{
					get
					{
						bool result = NativeMethods.THSBackend_cudnn_get_allow_tf32();
						CheckForErrors();
						return result;
					}
					set
					{
						NativeMethods.THSBackend_cudnn_set_allow_tf32(value);
						CheckForErrors();
					}
				}
			}
		}

		private static Device _CUDA;

		private static Device _MPS;

		public static readonly Device CPU;

		public static readonly Device META;

		private static ConcurrentDictionary<GCHandleDeleter, GCHandleDeleter> deleters;

		private static ScalarType default_dtype;

		private static Device default_device;

		private static Dictionary<Type, ScalarType> typeMap;

		public static ScalarType @bool;

		public static ScalarType uint8;

		public static ScalarType int8;

		public static ScalarType int16;

		public static ScalarType int32;

		public static ScalarType int64;

		public static ScalarType bfloat16;

		public static ScalarType float16;

		public static ScalarType float32;

		public static ScalarType float64;

		public static ScalarType complex64;

		public static ScalarType complex128;

		public static ScalarType @short;

		public static ScalarType @int;

		public static ScalarType @long;

		public static ScalarType half;

		public static ScalarType @float;

		public static ScalarType @double;

		public static ScalarType cfloat;

		public static ScalarType cdouble;

		public const TensorStringStyle julia = TensorStringStyle.Julia;

		public const TensorStringStyle numpy = TensorStringStyle.Numpy;

		public const TensorStringStyle csharp = TensorStringStyle.CSharp;

		private static TensorStringStyle _style;

		internal static string floatFormat;

		internal static string newLine;

		internal static int lineWidth;

		internal static int maxRows;

		internal static int maxColumns;

		private const string libtorchPackageVersion = "2.10.0.0";

		private const string cudaVersion = "12.8";

		private static bool nativeBackendLoaded;

		private static bool nativeBackendCudaLoaded;

		public static Device CUDA => _CUDA ?? (_CUDA = InitializeDevice(new Device(DeviceType.CUDA)));

		public static Device MPS => _MPS ?? (_MPS = InitializeDevice(new Device(DeviceType.MPS)));

		public static DisposeScope? CurrentDisposeScope => DisposeScopeManager.ThreadSingleton.CurrentDisposeScope;

		public static TensorStringStyle TensorStringStyle
		{
			get
			{
				return _style;
			}
			set
			{
				if (value == TensorStringStyle.Default)
				{
					throw new ArgumentException("The style cannot be set to 'Default'");
				}
				_style = value;
			}
		}

		private static bool isAppleSilicon
		{
			get
			{
				if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
				{
					return RuntimeInformation.OSArchitecture == Architecture.Arm64;
				}
				return false;
			}
		}

		private static string nativeRid
		{
			get
			{
				if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
				{
					if (!RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
					{
						if (!isAppleSilicon)
						{
							return "any";
						}
						return "osx-arm64";
					}
					return "linux-x64";
				}
				return "win-x64";
			}
		}

		private static string nativeGlob
		{
			get
			{
				if (!RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
				{
					if (!RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
					{
						return ".*\\.so(\\.\\d*)*";
					}
					return ".*\\.dylib\\.*";
				}
				return ".*\\.dll";
			}
		}

		public static string __version__ => "2.10.0.0";

		public static Device device(string description)
		{
			return InitializeDevice(new Device(description));
		}

		public static Device device(string deviceType, int index = -1)
		{
			return InitializeDevice(new Device(deviceType, index));
		}

		public static Device device(DeviceType deviceType, int index = -1)
		{
			return InitializeDevice(new Device(deviceType, index));
		}

		public static Device device(int index)
		{
			return new Device(DeviceType.CUDA, index);
		}

		public static Tensor as_tensor(Tensor data, ScalarType? dtype = null, Device? device = null)
		{
			if (dtype.HasValue && device != null && (data.dtype != dtype || data.device != device))
			{
				return data.to(dtype.Value, device).requires_grad_(data.requires_grad);
			}
			if (dtype.HasValue && data.dtype != dtype)
			{
				return data.to(dtype.Value).requires_grad_(data.requires_grad);
			}
			if (device != null && data.device != device)
			{
				return data.to(device).requires_grad_(data.requires_grad);
			}
			return data.alias();
		}

		public static Tensor as_tensor(IList<bool> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(bool[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<byte> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(byte[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<sbyte> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(sbyte[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<short> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(short[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<int> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(int[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<long> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(long[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<float> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(float[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<double> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(double[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<(float, float)> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor((float, float)[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor as_tensor(IList<Complex> rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray.ToArray(), dtype, device);
		}

		public static Tensor as_tensor(Complex[] rawArray, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(rawArray, dtype, device);
		}

		public static Tensor empty(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(size, dtype, device, requires_grad, names);
		}

		public static Tensor empty(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(size, dtype, device, requires_grad, names);
		}

		public static Tensor empty(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[1] { size }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(int size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[1] { size }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(int rows, int columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(int dim0, int dim1, int dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, names);
		}

		public static Tensor empty(int dim0, int dim1, int dim2, int dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _empty(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, names);
		}

		public static Tensor empty_like(Tensor input, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return input.empty_like(dtype, device, requires_grad);
		}

		public unsafe static Tensor empty_strided(long[] size, long[] strides, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			fixed (long* ptr = size)
			{
				fixed (long* ptr2 = strides)
				{
					IntPtr intPtr = NativeMethods.THSTensor_empty_strided((IntPtr)ptr, size.Length, (IntPtr)ptr2, strides.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
					if (intPtr == IntPtr.Zero)
					{
						GC.Collect();
						GC.WaitForPendingFinalizers();
						intPtr = NativeMethods.THSTensor_empty_strided((IntPtr)ptr, size.Length, (IntPtr)ptr2, strides.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
					}
					if (intPtr == IntPtr.Zero)
					{
						CheckForErrors();
					}
					Tensor tensor = new Tensor(intPtr);
					if (names != null && names.Length != 0)
					{
						tensor.rename_(names);
					}
					return tensor;
				}
			}
		}

		private unsafe static Tensor _empty(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			fixed (long* ptr = size)
			{
				IntPtr intPtr = NativeMethods.THSTensor_empty((IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_empty((IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		public static Tensor full(long[] size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(size, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(ReadOnlySpan<long> size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(size, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(long size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[1] { size }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(long rows, long columns, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[2] { rows, columns }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(long dim0, long dim1, long dim2, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[3] { dim0, dim1, dim2 }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(long dim0, long dim1, long dim2, long dim3, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[4] { dim0, dim1, dim2, dim3 }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(int size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[1] { size }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(int rows, int columns, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[2] { rows, columns }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(int dim0, int dim1, int dim2, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[3] { dim0, dim1, dim2 }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full(int dim0, int dim1, int dim2, int dim3, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _full(stackalloc long[4] { dim0, dim1, dim2, dim3 }, value, dtype, device, requires_grad, names);
		}

		public static Tensor full_like(Tensor input, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return input.full_like(value, dtype, device, requires_grad);
		}

		private unsafe static Tensor _full(ReadOnlySpan<long> size, Scalar value, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = ((!value.Type.IsIntegral()) ? new ScalarType?(get_default_dtype()) : new ScalarType?(ScalarType.Int64));
			}
			fixed (long* ptr = size)
			{
				IntPtr intPtr = NativeMethods.THSTensor_full((IntPtr)ptr, size.Length, value.Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_full((IntPtr)ptr, size.Length, value.Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		public static Tensor ones(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(size, dtype, device, requires_grad, names);
		}

		public static Tensor ones(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(size, dtype, device, requires_grad, names);
		}

		public static Tensor ones(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[1] { size }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(int size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[1] { size }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(int rows, int columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(int dim0, int dim1, int dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, names);
		}

		public static Tensor ones(int dim0, int dim1, int dim2, int dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _ones(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, names);
		}

		public static Tensor ones_like(Tensor input, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return input.ones_like(dtype, device, requires_grad);
		}

		private unsafe static Tensor _ones(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			fixed (long* ptr = size)
			{
				IntPtr intPtr = NativeMethods.THSTensor_ones((IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_ones((IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		public unsafe static Tensor randint(long low, long high, Size size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			long[] shape = size.Shape;
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = ScalarType.Int64;
			}
			ValidateIntegerRange(low, dtype.Value, "low");
			ValidateIntegerRange(high - 1, dtype.Value, "high");
			IntPtr intPtr = generator?.Handle ?? IntPtr.Zero;
			Tensor tensor = null;
			if (dtype == ScalarType.ComplexFloat32)
			{
				tensor = randint_c32(intPtr, low, high, shape, device, requires_grad, names);
			}
			else if (dtype == ScalarType.ComplexFloat64)
			{
				tensor = randint_c64(intPtr, low, high, shape, device, requires_grad, names);
			}
			if ((object)tensor == null)
			{
				fixed (long* ptr = shape)
				{
					IntPtr intPtr2 = NativeMethods.THSTensor_randint(intPtr, low, high, (IntPtr)ptr, shape.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
					if (intPtr2 == IntPtr.Zero)
					{
						GC.Collect();
						GC.WaitForPendingFinalizers();
						intPtr2 = NativeMethods.THSTensor_randint(intPtr, low, high, (IntPtr)ptr, shape.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
					}
					if (intPtr2 == IntPtr.Zero)
					{
						CheckForErrors();
					}
					tensor = new Tensor(intPtr2);
				}
			}
			if (names != null && names.Length != 0)
			{
				tensor.rename_(names);
			}
			return tensor;
		}

		public static Tensor randint(long high, Size size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return randint(0L, high, size, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randint(long high, long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return randint(0L, high, new Size(size), dtype, device, requires_grad, generator, names);
		}

		public static Tensor randint(long low, long high, long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return randint(low, high, new Size(size), dtype, device, requires_grad, generator, names);
		}

		public static Tensor randint(int low, int high, int[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return randint(low, high, new Size(size), dtype, device, requires_grad, generator, names);
		}

		public static Tensor randint(int high, int[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return randint(0L, high, new Size(size), dtype, device, requires_grad, generator, names);
		}

		public static bool randint_bool(Generator? generator = null)
		{
			int num = NativeMethods.THSTensor_randint_bool(generator?.Handle ?? IntPtr.Zero);
			if (num == -1)
			{
				CheckForErrors();
			}
			return num == 1;
		}

		public static int randint_int(int high, Generator? generator = null)
		{
			return randint_int(0, high, generator);
		}

		public static int randint_int(int low, int high, Generator? generator = null)
		{
			int result = NativeMethods.THSTensor_randint_int(generator?.Handle ?? IntPtr.Zero, low, high);
			CheckForErrors();
			return result;
		}

		public static long randint_long(long high, Generator? generator = null)
		{
			return randint_long(0L, high, generator);
		}

		public static long randint_long(long low, long high, Generator? generator = null)
		{
			long result = NativeMethods.THSTensor_randint_long(generator?.Handle ?? IntPtr.Zero, low, high);
			CheckForErrors();
			return result;
		}

		private unsafe static Tensor randint_c32(IntPtr genHandle, long low, long high, long[] size, Device device, bool requires_grad, string[]? names)
		{
			List<long> list = new List<long>();
			list.AddRange(size);
			list.Add(2L);
			long[] array = list.ToArray();
			fixed (long* ptr = array)
			{
				IntPtr intPtr = NativeMethods.THSTensor_randint(genHandle, low, high, (IntPtr)ptr, array.Length, 6, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_randint(genHandle, low, high, (IntPtr)ptr, array.Length, 6, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				IntPtr intPtr2 = NativeMethods.THSTensor_view_as_complex(intPtr);
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				IntPtr intPtr3 = NativeMethods.THSTensor_empty((IntPtr)ptr, size.Length, 9, (int)device.type, device.index, requires_grad);
				if (intPtr3 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				NativeMethods.THSTensor_copy_(intPtr3, intPtr2, non_blocking: false);
				CheckForErrors();
				NativeMethods.THSTensor_dispose(intPtr);
				NativeMethods.THSTensor_dispose(intPtr2);
				Tensor tensor = new Tensor(intPtr3);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		private unsafe static Tensor randint_c64(IntPtr genHandle, long low, long high, long[] size, Device device, bool requires_grad, string[]? names)
		{
			List<long> list = new List<long>();
			list.AddRange(size);
			list.Add(2L);
			long[] array = list.ToArray();
			fixed (long* ptr = array)
			{
				IntPtr intPtr = NativeMethods.THSTensor_randint(genHandle, low, high, (IntPtr)ptr, array.Length, 7, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_randint(genHandle, low, high, (IntPtr)ptr, array.Length, 7, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				IntPtr intPtr2 = NativeMethods.THSTensor_view_as_complex(intPtr);
				if (intPtr2 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				IntPtr intPtr3 = NativeMethods.THSTensor_empty((IntPtr)ptr, size.Length, 10, (int)device.type, device.index, requires_grad);
				if (intPtr3 == IntPtr.Zero)
				{
					CheckForErrors();
				}
				NativeMethods.THSTensor_copy_(intPtr3, intPtr2, non_blocking: false);
				CheckForErrors();
				NativeMethods.THSTensor_dispose(intPtr);
				NativeMethods.THSTensor_dispose(intPtr2);
				Tensor tensor = new Tensor(intPtr3);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		private unsafe static Tensor _rand(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			if (dtype.HasValue && is_integral(dtype.Value))
			{
				throw new ArgumentException($"torch.rand() was passed a bad dtype: {dtype}. It must be floating point or complex.", "dtype");
			}
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			IntPtr generator2 = generator?.Handle ?? IntPtr.Zero;
			fixed (long* ptr = size)
			{
				IntPtr intPtr = NativeMethods.THSTensor_rand(generator2, (IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_rand(generator2, (IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		public static Tensor rand(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(size, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(size, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[1] { size }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(int size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[1] { size }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(int rows, int columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(int dim0, int dim1, int dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor rand(int dim0, int dim1, int dim2, int dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _rand(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, generator, names);
		}

		public static double rand_float(Generator? generator = null)
		{
			double result = NativeMethods.THSTensor_rand_float(generator?.Handle ?? IntPtr.Zero);
			CheckForErrors();
			return result;
		}

		private unsafe static Tensor _randn(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			if (dtype.HasValue && is_integral(dtype.Value))
			{
				throw new ArgumentException($"torch.randn() was passed a bad dtype: {dtype}. It must be floating point or complex.", "dtype");
			}
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			IntPtr generator2 = generator?.Handle ?? IntPtr.Zero;
			fixed (long* ptr = size)
			{
				IntPtr intPtr = NativeMethods.THSTensor_randn(generator2, (IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_randn(generator2, (IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		public static Tensor randn(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(size, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(size, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[1] { size }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(int size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[1] { size }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(int rows, int columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(int dim0, int dim1, int dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, generator, names);
		}

		public static Tensor randn(int dim0, int dim1, int dim2, int dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return _randn(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, generator, names);
		}

		public static double randn_float(Generator? generator = null)
		{
			double result = NativeMethods.THSTensor_randn_float(generator?.Handle ?? IntPtr.Zero);
			CheckForErrors();
			return result;
		}

		public static Tensor arange(Scalar start, Scalar stop, Scalar step, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = ((!start.Type.IsIntegral() || !stop.Type.IsIntegral() || !step.Type.IsIntegral()) ? new ScalarType?(get_default_dtype()) : new ScalarType?(ScalarType.Int64));
			}
			if (dtype == ScalarType.ComplexFloat32)
			{
				return ComplexFloat32Tensor.arange(start, stop, step, device, requires_grad);
			}
			if (dtype == ScalarType.ComplexFloat64)
			{
				return ComplexFloat64Tensor.arange(start, stop, step, device, requires_grad);
			}
			IntPtr intPtr = NativeMethods.THSTensor_arange(start.Handle, stop.Handle, step.Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_arange(start.Handle, stop.Handle, step.Handle, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor arange(Scalar start, Scalar stop, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return arange(start, stop, 1, dtype, device, requires_grad);
		}

		public static Tensor arange(Scalar stop, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return arange(0, stop, 1, dtype, device, requires_grad);
		}

		public static Tensor eye(long rows, long columns = -1L, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			columns = ((columns == -1) ? rows : columns);
			IntPtr intPtr = NativeMethods.THSTensor_eye(rows, columns, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_eye(rows, columns, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			Tensor tensor = new Tensor(intPtr);
			if (names != null && names.Length != 0)
			{
				tensor.rename_(names);
			}
			return tensor;
		}

		public static Tensor normal(double mean, double std, ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null, string[]? names = null)
		{
			return randn(size, dtype, device, requires_grad: false, generator, names).mul_(std).add_(mean).requires_grad_(requires_grad);
		}

		private unsafe static Tensor _tensor_generic(Array rawArray, ReadOnlySpan<long> dimensions, sbyte origType, ScalarType? dtype, Device? device, bool requires_grad, bool clone = true, string[]? names = null)
		{
			long num = 1L;
			ReadOnlySpan<long> readOnlySpan = dimensions;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				long num2 = readOnlySpan[i];
				num *= num2;
			}
			if (origType == 9)
			{
				num *= 2;
			}
			if (num > rawArray.LongLength)
			{
				throw new ArgumentException($"mismatched total size creating a tensor from an array: {num} vs. {rawArray.LongLength}");
			}
			device = InitializeDevice(device);
			if (clone)
			{
				rawArray = (Array)rawArray.Clone();
			}
			GCHandle value = GCHandle.Alloc(rawArray, GCHandleType.Pinned);
			IntPtr rawArray2 = value.AddrOfPinnedObject();
			IntPtr gchp = GCHandle.ToIntPtr(value);
			GCHandleDeleter deleter = null;
			deleter = delegate
			{
				GCHandle.FromIntPtr(gchp).Free();
				deleters.TryRemove(deleter, out deleter);
			};
			deleters.TryAdd(deleter, deleter);
			dtype = dtype ?? new ScalarType?((ScalarType)origType);
			void* ptr = null;
			_ = (IntPtr)ptr;
			fixed (long* ptr2 = dimensions)
			{
				IntPtr intPtr = NativeMethods.THSTensor_new(rawArray2, deleter, (IntPtr)ptr2, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_new(rawArray2, deleter, (IntPtr)ptr2, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		private unsafe static Tensor _tensor_generic<T>(Memory<T> rawArray, ReadOnlySpan<long> dimensions, sbyte origType, ScalarType? dtype, Device? device, bool requires_grad, bool clone = true, string[]? names = null)
		{
			if (clone)
			{
				return _tensor_generic(rawArray.ToArray(), dimensions, origType, dtype, device, requires_grad, clone: false, names);
			}
			long num = 1L;
			ReadOnlySpan<long> readOnlySpan = dimensions;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				long num2 = readOnlySpan[i];
				num *= num2;
			}
			if (origType == 9)
			{
				num *= 2;
			}
			if (num > rawArray.Length)
			{
				throw new ArgumentException($"mismatched total size creating a tensor from an array: {num} vs. {rawArray.Length}");
			}
			device = InitializeDevice(device);
			dtype = dtype ?? new ScalarType?((ScalarType)origType);
			MemoryHandle dataHandle = rawArray.Pin();
			IntPtr rawArray2 = (IntPtr)dataHandle.Pointer;
			GCHandleDeleter deleter = null;
			deleter = delegate
			{
				dataHandle.Dispose();
				deleters.TryRemove(deleter, out deleter);
			};
			deleters.TryAdd(deleter, deleter);
			void* ptr = null;
			_ = (IntPtr)ptr;
			fixed (long* ptr2 = dimensions)
			{
				IntPtr intPtr = NativeMethods.THSTensor_new(rawArray2, deleter, (IntPtr)ptr2, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_new(rawArray2, deleter, (IntPtr)ptr2, dimensions.Length, origType, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		public static Tensor from_array(Array rawArray, Device? device = null)
		{
			Type? obj = rawArray.GetType().GetElementType() ?? throw new InvalidOperationException("rawArray.GetType().GetElementType() returned null.");
			if (obj == typeof((float, float)))
			{
				throw new NotImplementedException("from_array() for (float,float) elements.");
			}
			ScalarType value = ToScalarType(obj);
			return from_array(rawArray, value, (device == null) ? CPU : device);
		}

		public static Tensor from_array(Array rawArray, ScalarType? dtype, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			long[] array = GetShape(rawArray);
			Type elementType = rawArray.GetType().GetElementType();
			if ((object)elementType == null)
			{
				throw new InvalidOperationException("rawArray.GetType().GetElementType() returned null.");
			}
			if (elementType == typeof((float, float)))
			{
				return tensor(rawArray.Cast<(float, float)>().ToArray(), array, dtype, device, requires_grad, names);
			}
			ScalarType origType = ToScalarType(elementType);
			return _tensor_generic(rawArray, array, (sbyte)origType, dtype, device, requires_grad, clone: false, names);
			static long[] GetShape(Array arr)
			{
				long[] array2 = new long[arr.Rank];
				for (int i = 0; i < arr.Rank; i++)
				{
					array2[i] = arr.GetLength(i);
				}
				return array2;
			}
		}

		public static Tensor as_tensor(Array data, ScalarType? dtype = null, Device? device = null)
		{
			return from_array(data, dtype, device);
		}

		public static Tensor frombuffer(Array rawArray, ScalarType dtype, long count = -1L, long offset = 0L, bool requires_grad = false)
		{
			long longLength = rawArray.LongLength;
			if (offset < 0 || offset >= longLength)
			{
				throw new ArgumentException($"invalid value for 'offset': {offset}");
			}
			if (count < 0)
			{
				count = longLength - offset;
			}
			if (count > longLength - offset)
			{
				throw new IndexOutOfRangeException($"element count is too large: {count}");
			}
			Device device = InitializeDevice(CPU);
			ScalarType scalarType = ToScalarType(rawArray.GetType().GetElementType());
			switch (scalarType)
			{
			case ScalarType.Int16:
				offset *= 2;
				break;
			case ScalarType.Int32:
			case ScalarType.Float32:
				offset *= 4;
				break;
			case ScalarType.Int64:
			case ScalarType.Float64:
				offset *= 8;
				break;
			case ScalarType.ComplexFloat64:
				offset *= 16;
				break;
			case ScalarType.ComplexFloat32:
				throw new NotImplementedException("frombuffer(ComplexFloat32)");
			}
			GCHandle value = GCHandle.Alloc(rawArray, GCHandleType.Pinned);
			IntPtr rawArray2 = value.AddrOfPinnedObject();
			IntPtr gchp = GCHandle.ToIntPtr(value);
			GCHandleDeleter deleter = null;
			deleter = delegate
			{
				GCHandle.FromIntPtr(gchp).Free();
				deleters.TryRemove(deleter, out deleter);
			};
			deleters.TryAdd(deleter, deleter);
			IntPtr intPtr = NativeMethods.THSTensor_frombuffer(rawArray2, deleter, count, offset, (sbyte)scalarType, (sbyte)dtype, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_frombuffer(rawArray2, deleter, count, offset, (sbyte)scalarType, (sbyte)dtype, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			Tensor tensor = new Tensor(intPtr);
			if (dtype != scalarType)
			{
				tensor = tensor.to_type(dtype);
			}
			return tensor;
		}

		public unsafe static Tensor sparse_coo_tensor(Tensor indices, Tensor values, long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = values.dtype;
			}
			fixed (long* ptr = size)
			{
				IntPtr intPtr = NativeMethods.THSTensor_sparse(indices.Handle, values.Handle, (IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (intPtr == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					intPtr = NativeMethods.THSTensor_sparse(indices.Handle, values.Handle, (IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(intPtr);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		[Obsolete("This method had the wrong name when it was added. Use torch.sparse_coo_tensor instead.")]
		public static Tensor sparse(Tensor indices, Tensor values, long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return sparse(indices, values, size, dtype, device, requires_grad, names);
		}

		public static Tensor complex(Tensor real, Tensor imag)
		{
			IntPtr intPtr = NativeMethods.THSTensor_complex(real.Handle, imag.Handle);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor polar(Tensor abs, Tensor angle)
		{
			IntPtr intPtr = NativeMethods.THSTensor_polar(abs.Handle, angle.Handle);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor from_file(string filename, bool? shared = null, long? size = 0L, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			IntPtr intPtr = NativeMethods.THSTensor_from_file(StringEncoder.GetNullTerminatedUTF8ByteArray(filename), (sbyte)((!shared.HasValue) ? (-1) : (shared.Value ? 1 : 0)), size.HasValue ? size.Value : (-1), (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor linspace(double start, double end, long steps, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			IntPtr intPtr = NativeMethods.THSTensor_linspace(start, end, steps, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_linspace(start, end, steps, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor logspace(double start, double end, long steps, double @base = 10.0, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			IntPtr intPtr = NativeMethods.THSTensor_logspace(start, end, steps, @base, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_logspace(start, end, steps, @base, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		private static void ValidateIntegerRange(long value, ScalarType dtype, string argument)
		{
			switch (dtype)
			{
			case ScalarType.Byte:
				if (value < 0 || value > 255)
				{
					throw new ArgumentOutOfRangeException(argument, value, $"The value is outside the range of {dtype}");
				}
				break;
			case ScalarType.Int8:
				if (value < -128 || value > 127)
				{
					throw new ArgumentOutOfRangeException(argument, value, $"The value is outside the range of {dtype}");
				}
				break;
			case ScalarType.Int16:
				if (value < -32768 || value > 32767)
				{
					throw new ArgumentOutOfRangeException(argument, value, $"The value is outside the range of {dtype}");
				}
				break;
			case ScalarType.Int32:
				if (value < int.MinValue || value > int.MaxValue)
				{
					throw new ArgumentOutOfRangeException(argument, value, $"The value is outside the range of {dtype}");
				}
				break;
			}
		}

		static torch()
		{
			CPU = InitializeDevice(new Device(DeviceType.CPU));
			META = InitializeDevice(new Device(DeviceType.META));
			default_dtype = ScalarType.Float32;
			default_device = new Device(DeviceType.CPU);
			typeMap = new Dictionary<Type, ScalarType>
			{
				{
					typeof(bool),
					ScalarType.Bool
				},
				{
					typeof(byte),
					ScalarType.Byte
				},
				{
					typeof(sbyte),
					ScalarType.Int8
				},
				{
					typeof(short),
					ScalarType.Int16
				},
				{
					typeof(int),
					ScalarType.Int32
				},
				{
					typeof(long),
					ScalarType.Int64
				},
				{
					typeof(float),
					ScalarType.Float32
				},
				{
					typeof(double),
					ScalarType.Float64
				},
				{
					typeof((float, float)),
					ScalarType.ComplexFloat32
				},
				{
					typeof(Complex),
					ScalarType.ComplexFloat64
				}
			};
			@bool = ScalarType.Bool;
			uint8 = ScalarType.Byte;
			int8 = ScalarType.Int8;
			int16 = ScalarType.Int16;
			int32 = ScalarType.Int32;
			int64 = ScalarType.Int64;
			bfloat16 = ScalarType.BFloat16;
			float16 = ScalarType.Float16;
			float32 = ScalarType.Float32;
			float64 = ScalarType.Float64;
			complex64 = ScalarType.ComplexFloat32;
			complex128 = ScalarType.ComplexFloat64;
			@short = ScalarType.Int16;
			@int = ScalarType.Int32;
			@long = ScalarType.Int64;
			half = ScalarType.Float16;
			@float = ScalarType.Float32;
			@double = ScalarType.Float64;
			cfloat = ScalarType.ComplexFloat32;
			cdouble = ScalarType.ComplexFloat64;
			_style = TensorStringStyle.Julia;
			floatFormat = "g5";
			newLine = Environment.NewLine;
			lineWidth = 100;
			maxRows = 6;
			maxColumns = 6;
			nativeBackendLoaded = false;
			nativeBackendCudaLoaded = false;
			deleters = new ConcurrentDictionary<GCHandleDeleter, GCHandleDeleter>();
			TryInitializeDeviceType(DeviceType.CUDA);
		}

		public static Tensor tensor(bool scalar, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newBoolScalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			Tensor tensor = new Tensor(intPtr);
			return dtype.HasValue ? tensor.to(dtype.Value, device) : tensor.to(device);
		}

		public static Tensor tensor(IList<bool> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray.ToArray(), dimensions, 11, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(bool[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 11, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(bool[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 11, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<bool> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<bool> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<bool> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<bool> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(bool[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 11, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(bool[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 11, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(bool[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 11, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor BoolTensor(Tensor t)
		{
			return t.to(ScalarType.Bool);
		}

		public static Tensor tensor(byte scalar, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newByteScalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor tensor(IList<byte> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray.ToArray(), dimensions, 0, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(byte[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 0, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(byte[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 0, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<byte> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<byte> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<byte> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<byte> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(byte[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 0, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(byte[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 0, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(byte[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 0, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<byte> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 0, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor ByteTensor(Tensor t)
		{
			return t.to(ScalarType.Byte);
		}

		public static Tensor tensor(Complex scalar, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat64Scalar(scalar.Real, scalar.Imaginary, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return InstantiateTensorWithLeakSafeTypeChange(intPtr, dtype);
		}

		public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return tensor(rawArray.ToArray(), dimensions, dtype, device, requires_grad, names);
		}

		public static Tensor tensor((float Real, float Imaginary)[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			float[] array = new float[rawArray.Length * 2];
			for (int i = 0; i < rawArray.Length; i++)
			{
				array[i * 2] = rawArray[i].Real;
				array[i * 2 + 1] = rawArray[i].Imaginary;
			}
			Array rawArray2 = array;
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray2, span, 9, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor((float Real, float Imaginary)[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			float[] array = new float[rawArray.Length * 2];
			for (int i = 0; i < rawArray.Length; i++)
			{
				array[i * 2] = rawArray[i].Real;
				array[i * 2 + 1] = rawArray[i].Imaginary;
			}
			return _tensor_generic(array, dimensions, 9, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<(float Real, float Imaginary)> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor((float Real, float Imaginary)[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			float[,] array = new float[(int)checked((nint)rawArray.GetLongLength(0)), (int)checked((nint)unchecked(rawArray.GetLongLength(1) * 2))];
			for (int i = 0; i < rawArray.GetLongLength(0); i++)
			{
				for (int j = 0; j < rawArray.GetLongLength(1); j++)
				{
					array[i, j * 2] = rawArray[i, j].Real;
					array[i, j * 2 + 1] = rawArray[i, j].Imaginary;
				}
			}
			Array rawArray2 = array;
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray2, span, 9, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor((float Real, float Imaginary)[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			float[,,] array = new float[(int)checked((nint)rawArray.GetLongLength(0)), (int)checked((nint)rawArray.GetLongLength(1)), (int)checked((nint)unchecked(rawArray.GetLongLength(2) * 2))];
			for (int i = 0; i < rawArray.GetLongLength(0); i++)
			{
				for (int j = 0; j < rawArray.GetLongLength(1); j++)
				{
					for (int k = 0; k < rawArray.GetLongLength(2); k++)
					{
						array[i, j, k * 2] = rawArray[i, j, k].Real;
						array[i, j, k * 2 + 1] = rawArray[i, j, k].Imaginary;
					}
				}
			}
			Array rawArray2 = array;
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray2, span, 9, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor((float Real, float Imaginary)[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			float[,,,] array = new float[(int)checked((nint)rawArray.GetLongLength(0)), (int)checked((nint)rawArray.GetLongLength(1)), (int)checked((nint)rawArray.GetLongLength(2)), (int)checked((nint)unchecked(rawArray.GetLongLength(3) * 2))];
			for (int i = 0; i < rawArray.GetLongLength(0); i++)
			{
				for (int j = 0; j < rawArray.GetLongLength(1); j++)
				{
					for (int k = 0; k < rawArray.GetLongLength(2); k++)
					{
						for (int l = 0; l < rawArray.GetLongLength(3); l++)
						{
							array[i, j, k, l * 2] = rawArray[i, j, k, l].Real;
							array[i, j, k, l * 2 + 1] = rawArray[i, j, k, l].Imaginary;
						}
					}
				}
			}
			Array rawArray2 = array;
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray2, span, 9, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<Complex> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return tensor(rawArray.ToArray(), dimensions, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(Complex[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 10, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Complex[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 10, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<Complex> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<Complex> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<Complex> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<Complex> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(Complex[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 10, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Complex[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 10, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Complex[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 10, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<Complex> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 10, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(double scalar, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newFloat64Scalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return InstantiateTensorWithLeakSafeTypeChange(intPtr, dtype);
		}

		public static Tensor tensor((double Real, double Imaginary) scalar, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return tensor(scalar.Real, scalar.Imaginary, dtype, device, requires_grad);
		}

		public static Tensor tensor(double real, double imaginary, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat64Scalar(real, imaginary, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return InstantiateTensorWithLeakSafeTypeChange(intPtr, dtype);
		}

		public static Tensor tensor(IList<double> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Array rawArray2 = rawArray.ToArray();
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return _tensor_generic(rawArray2, span, 7, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(double[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(double[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<double> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Array rawArray2 = rawArray.ToArray();
			Span<long> span = stackalloc long[2] { rows, columns };
			return _tensor_generic(rawArray2, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<double> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Array rawArray2 = rawArray.ToArray();
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return _tensor_generic(rawArray2, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<double> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Array rawArray2 = rawArray.ToArray();
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return _tensor_generic(rawArray2, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(double[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(double[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(double[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<double> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 7, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor DoubleTensor(Tensor t)
		{
			return t.to(ScalarType.Float64);
		}

		public static Tensor tensor(float scalar, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newFloat32Scalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor tensor(float real, float imaginary, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newComplexFloat32Scalar(real, imaginary, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return InstantiateTensorWithLeakSafeTypeChange(intPtr, dtype);
		}

		public static Tensor tensor((float Real, float Imaginary) scalar, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return tensor(scalar.Real, scalar.Imaginary, dtype, device);
		}

		public static Tensor tensor(IList<float> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray.ToArray(), dimensions, 6, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(float[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 6, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(float[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 6, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<float> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<float> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<float> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<float> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(float[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 6, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(float[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 6, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(float[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 6, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<float> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 6, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor FloatTensor(Tensor t)
		{
			return t.to(ScalarType.Float32);
		}

		public static Tensor tensor(int scalar, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newInt32Scalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor tensor(IList<int> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray.ToArray(), dimensions, 3, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(int[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 3, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(int[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 3, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<int> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<int> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<int> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(int[] rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(int[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 3, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(int[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 3, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(int[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 3, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<int> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 3, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor IntTensor(Tensor t)
		{
			return t.to(ScalarType.Int32);
		}

		public static Tensor tensor(long scalar, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newInt64Scalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return InstantiateTensorWithLeakSafeTypeChange(intPtr, dtype);
		}

		public static Tensor tensor(IList<long> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_i64(rawArray.ToArray(), dimensions, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(long[] dataArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { dataArray.LongLength };
			return _tensor_i64(dataArray, span, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(long[] dataArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_i64(dataArray, dimensions, dtype, device, requires_grad, clone: false, names);
		}

		private static Tensor _tensor_i64(Array rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype, Device? device, bool requires_grad, bool clone = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 4, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<long> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<long> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<long> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<long> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(long[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_i64(rawArray, span, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(long[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_i64(rawArray, span, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(long[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_i64(rawArray, span, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(Memory<long> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 4, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor LongTensor(Tensor t)
		{
			return t.to(ScalarType.Int64);
		}

		public static Tensor tensor(sbyte scalar, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newInt8Scalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor tensor(IList<sbyte> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray.ToArray(), dimensions, 1, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(sbyte[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 1, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(sbyte[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 1, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<sbyte> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<sbyte> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<sbyte> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<sbyte> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(sbyte[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 1, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(sbyte[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 1, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(sbyte[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 1, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<sbyte> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 1, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(short scalar, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			IntPtr intPtr = NativeMethods.THSTensor_newInt16Scalar(scalar, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor tensor(IList<short> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray.ToArray(), dimensions, 2, dtype, device, requires_grad, clone: false, names);
		}

		public static Tensor tensor(short[] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.LongLength };
			return _tensor_generic(rawArray, span, 2, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(short[] rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 2, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(IList<short> rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[1] { rawArray.Count };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<short> rawArray, long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2] { rows, columns };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<short> rawArray, long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3] { dim0, dim1, dim2 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(IList<short> rawArray, long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4] { dim0, dim1, dim2, dim3 };
			return tensor(rawArray, span, dtype, device, requires_grad, names);
		}

		public static Tensor tensor(short[,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[2]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1)
			};
			return _tensor_generic(rawArray, span, 2, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(short[,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[3]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2)
			};
			return _tensor_generic(rawArray, span, 2, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(short[,,,] rawArray, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			Span<long> span = stackalloc long[4]
			{
				rawArray.GetLongLength(0),
				rawArray.GetLongLength(1),
				rawArray.GetLongLength(2),
				rawArray.GetLongLength(3)
			};
			return _tensor_generic(rawArray, span, 2, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor tensor(Memory<short> rawArray, ReadOnlySpan<long> dimensions, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _tensor_generic(rawArray, dimensions, 2, dtype, device, requires_grad, clone: true, names);
		}

		public static Tensor ShortTensor(Tensor t)
		{
			return t.to(ScalarType.Int16);
		}

		public static Tensor zeros(long[] size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(size, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(size, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(long size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[1] { size }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(long rows, long columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(long dim0, long dim1, long dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(long dim0, long dim1, long dim2, long dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(int size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[1] { size }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(int rows, int columns, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[2] { rows, columns }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(int dim0, int dim1, int dim2, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[3] { dim0, dim1, dim2 }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros(int dim0, int dim1, int dim2, int dim3, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return _zeros(stackalloc long[4] { dim0, dim1, dim2, dim3 }, dtype, device, requires_grad, names);
		}

		public static Tensor zeros_like(Tensor input, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			return input.zeros_like(dtype, device, requires_grad);
		}

		private unsafe static Tensor _zeros(ReadOnlySpan<long> size, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, string[]? names = null)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			IntPtr zero = IntPtr.Zero;
			fixed (long* ptr = size)
			{
				zero = NativeMethods.THSTensor_zeros((IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				if (zero == IntPtr.Zero)
				{
					GC.Collect();
					GC.WaitForPendingFinalizers();
					zero = NativeMethods.THSTensor_zeros((IntPtr)ptr, size.Length, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
				}
				if (zero == IntPtr.Zero)
				{
					CheckForErrors();
				}
				Tensor tensor = new Tensor(zero);
				if (names != null && names.Length != 0)
				{
					tensor.rename_(names);
				}
				return tensor;
			}
		}

		internal static ScalarType ToScalarType(Type t)
		{
			if (typeMap.TryGetValue(t, out var value))
			{
				return value;
			}
			throw new NotSupportedException("The type " + t.FullName + " is not supported.");
		}

		public static FInfo finfo()
		{
			return finfo(default_dtype);
		}

		public static FInfo finfo(ScalarType dtype)
		{
			switch (dtype)
			{
			case ScalarType.BFloat16:
				return new FInfo
				{
					bits = 16,
					eps = 1.0 / 128.0,
					max = 3.3895313892515355E+38,
					min = -3.3895313892515355E+38,
					tiny = 1.1754943508222875E-38,
					smallest_normal = 1.1754943508222875E-38,
					resolution = 0.01
				};
			case ScalarType.Float16:
				return new FInfo
				{
					bits = 16,
					eps = 0.0009765625,
					max = 65504.0,
					min = -65504.0,
					tiny = 6.103515625E-05,
					smallest_normal = 6.103515625E-05,
					resolution = 0.001
				};
			case ScalarType.Float32:
			case ScalarType.ComplexFloat32:
				return new FInfo
				{
					bits = 32,
					eps = 1.1920928955078125E-07,
					max = 3.4028234663852886E+38,
					min = -3.4028234663852886E+38,
					tiny = 1.1754943508222875E-38,
					smallest_normal = 1.1754943508222875E-38,
					resolution = 1E-06
				};
			case ScalarType.Float64:
			case ScalarType.ComplexFloat64:
				return new FInfo
				{
					bits = 64,
					eps = 2.220446049250313E-16,
					max = double.MaxValue,
					min = double.MinValue,
					tiny = 2.2250738585072014E-308,
					smallest_normal = 2.2250738585072014E-308,
					resolution = 1E-15
				};
			default:
				throw new ArgumentException("'dtype' must be floating point or complex");
			}
		}

		public static bool is_integral(ScalarType type)
		{
			if ((uint)type <= 4u || type == ScalarType.Bool)
			{
				return true;
			}
			return false;
		}

		public static bool is_floating_point(ScalarType type)
		{
			if ((uint)(type - 5) <= 2u || type == ScalarType.BFloat16)
			{
				return true;
			}
			return false;
		}

		public static bool is_complex(ScalarType type)
		{
			if ((uint)(type - 9) <= 1u)
			{
				return true;
			}
			return false;
		}

		public static long max_int_value(ScalarType type)
		{
			return type switch
			{
				ScalarType.Byte => 255L, 
				ScalarType.Int8 => 127L, 
				ScalarType.Int16 => 32767L, 
				ScalarType.Int32 => 2147483647L, 
				ScalarType.Int64 => long.MaxValue, 
				_ => throw new ArgumentException("Not an integral type"), 
			};
		}

		public static bool is_integral(Tensor t)
		{
			return is_integral(t.dtype);
		}

		public static DisposeScope NewDisposeScope()
		{
			return DisposeScopeManager.ThreadSingleton.NewDisposeScope();
		}

		public static Tensor WrappedTensorDisposeScope(Func<Tensor> expr)
		{
			using (NewDisposeScope())
			{
				return expr().MoveToOuterDisposeScope();
			}
		}

		internal static Tensor InstantiateTensorWithLeakSafeTypeChange(IntPtr handle, ScalarType? dtype)
		{
			Tensor tensor = new Tensor(handle);
			if (dtype.HasValue && tensor.dtype != dtype.Value)
			{
				Tensor result = tensor.to_type(dtype.Value);
				tensor.Dispose();
				return result;
			}
			return tensor;
		}

		public static void set_printoptions(int precision, int? linewidth = null, string? newLine = null, bool sci_mode = false, int? maxRows = null, int? maxColumns = null)
		{
			floatFormat = (sci_mode ? $"E{precision}" : $"F{precision}");
			if (newLine != null)
			{
				torch.newLine = newLine;
			}
			if (linewidth.HasValue)
			{
				lineWidth = linewidth.Value;
			}
			if (maxRows.HasValue)
			{
				torch.maxRows = maxRows.Value;
			}
			if (maxColumns.HasValue)
			{
				torch.maxColumns = maxColumns.Value;
			}
		}

		public static void set_printoptions(TensorStringStyle? style = null, string? floatFormat = null, int? linewidth = null, string? newLine = null, int? maxRows = null, int? maxColumns = null)
		{
			if (style.HasValue)
			{
				_style = style.Value;
			}
			if (floatFormat != null)
			{
				torch.floatFormat = floatFormat;
			}
			if (newLine != null)
			{
				torch.newLine = newLine;
			}
			if (linewidth.HasValue)
			{
				lineWidth = linewidth.Value;
			}
			if (maxRows.HasValue)
			{
				torch.maxRows = maxRows.Value;
			}
			if (maxColumns.HasValue)
			{
				torch.maxColumns = maxColumns.Value;
			}
		}

		public static Tensor addbmm(Tensor input, Tensor batch1, Tensor batch2, float beta = 1f, float alpha = 1f)
		{
			return input.addbmm(batch1, batch2, beta, alpha);
		}

		public static Tensor addbmm_(Tensor input, Tensor batch1, Tensor batch2, float beta = 1f, float alpha = 1f)
		{
			return input.addbmm_(batch1, batch2, beta, alpha);
		}

		public static Tensor addmm(Tensor input, Tensor mat1, Tensor mat2, float beta, float alpha)
		{
			return input.addmm(mat1, mat2, beta, alpha);
		}

		public static Tensor addmm_(Tensor input, Tensor mat1, Tensor mat2, float beta, float alpha)
		{
			return input.addmm_(mat1, mat2, beta, alpha);
		}

		public static Tensor addmv(Tensor input, Tensor mat1, Tensor mat2, float beta, float alpha)
		{
			return input.addmv(mat1, mat2, beta, alpha);
		}

		public static Tensor addmv_(Tensor input, Tensor mat1, Tensor mat2, float beta, float alpha)
		{
			return input.addmv_(mat1, mat2, beta, alpha);
		}

		public static Tensor addr(Tensor input, Tensor vec1, Tensor vec2, float beta = 1f, float alpha = 1f)
		{
			return input.addr(vec1, vec2, beta, alpha);
		}

		public static Tensor addr_(Tensor input, Tensor vec1, Tensor vec2, float beta = 1f, float alpha = 1f)
		{
			return input.addr_(vec1, vec2, beta, alpha);
		}

		public static Tensor baddbmm(Tensor input, Tensor batch1, Tensor batch2, float beta = 1f, float alpha = 1f)
		{
			return input.baddbmm(batch1, batch2, beta, alpha);
		}

		public static Tensor bmm(Tensor input, Tensor batch2)
		{
			return input.bmm(batch2);
		}

		public static Tensor chain_matmul(params Tensor[] matrices)
		{
			return linalg.multi_dot(matrices);
		}

		public static Tensor cholesky(Tensor input)
		{
			return input.cholesky();
		}

		public static Tensor cholesky_inverse(Tensor input, bool upper = false)
		{
			return input.cholesky_inverse(upper);
		}

		public static Tensor cholesky_solve(Tensor input, Tensor input2, bool upper = false)
		{
			return input.cholesky_solve(input2, upper);
		}

		public static Tensor dot(Tensor input, Tensor other)
		{
			return input.dot(other);
		}

		[Obsolete("Method removed in Pytorch. Please use the `torch.linalg.eig` function instead.", true)]
		public static (Tensor eigenvalues, Tensor eigenvectors) eig(Tensor input, bool eigenvectors = false)
		{
			throw new NotImplementedException();
		}

		public static (Tensor a, Tensor tau) geqrf(Tensor input)
		{
			return input.geqrf();
		}

		public static Tensor ger(Tensor input, Tensor vec2)
		{
			return input.ger(vec2);
		}

		public static Tensor inner(Tensor input, Tensor vec2)
		{
			return input.inner(vec2);
		}

		public static Tensor inverse(Tensor input)
		{
			return linalg.inv(input);
		}

		public static Tensor det(Tensor input)
		{
			return input.det();
		}

		public static Tensor logdet(Tensor input)
		{
			return input.logdet();
		}

		public static (Tensor res, Tensor logabsdet) slogdet(Tensor A)
		{
			return linalg.slogdet(A);
		}

		public static (Tensor Solution, Tensor QR) lstsq(Tensor B, Tensor A)
		{
			IntPtr intPtr2;
			IntPtr intPtr = NativeMethods.THSTorch_lstsq(B.Handle, A.Handle, out intPtr2);
			if (intPtr == IntPtr.Zero || intPtr2 == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return (Solution: new Tensor(intPtr), QR: new Tensor(intPtr2));
		}

		public static (Tensor A_LU, Tensor? pivots, Tensor? infos) lu(Tensor A, bool pivot = true, bool get_infos = false)
		{
			IntPtr infos;
			IntPtr pivots;
			IntPtr intPtr = NativeMethods.THSTensor_lu(A.Handle, pivot, get_infos, out infos, out pivots);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return (A_LU: new Tensor(intPtr), pivots: (pivots == IntPtr.Zero) ? null : new Tensor(pivots), infos: (infos == IntPtr.Zero) ? null : new Tensor(infos));
		}

		public static Tensor lu_solve(Tensor b, Tensor LU_data, Tensor LU_pivots)
		{
			IntPtr intPtr = NativeMethods.THSTensor_lu_solve(b.Handle, LU_data.Handle, LU_pivots.Handle);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static (Tensor P, Tensor? L, Tensor? U) lu_unpack(Tensor LU_data, Tensor LU_pivots, bool unpack_data = true, bool unpack_pivots = true)
		{
			IntPtr L;
			IntPtr U;
			IntPtr intPtr = NativeMethods.THSTensor_lu_unpack(LU_data.Handle, LU_pivots.Handle, unpack_data, unpack_pivots, out L, out U);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return (P: new Tensor(intPtr), L: (L == IntPtr.Zero) ? null : new Tensor(L), U: (U == IntPtr.Zero) ? null : new Tensor(U));
		}

		public static Tensor matmul(Tensor input, Tensor target)
		{
			return input.matmul(target);
		}

		public static Tensor matrix_power(Tensor input, int n)
		{
			return input.matrix_power(n);
		}

		[Obsolete("This function was deprecated since version 1.9 and is now removed. Please use the 'torch.linalg.matrix_rank' function instead.", true)]
		public static Tensor matrix_rank(Tensor input, float? tol = null, bool symmetric = false)
		{
			throw new NotImplementedException();
		}

		public static Tensor matrix_exp(Tensor input)
		{
			return input.matrix_exp();
		}

		public static Tensor mm(Tensor input, Tensor target)
		{
			return input.mm(target);
		}

		public static Tensor mv(Tensor input, Tensor target)
		{
			return input.mv(target);
		}

		public static Tensor orgqr(Tensor input, Tensor tau)
		{
			return linalg.householder_product(input, tau);
		}

		public static Tensor ormqr(Tensor input, Tensor tau, Tensor other, bool left = true, bool transpose = false)
		{
			return input.ormqr(tau, other, left, transpose);
		}

		public static Tensor outer(Tensor input, Tensor vec2)
		{
			return input.outer(vec2);
		}

		public static Tensor pinverse(Tensor input, double rcond = 1E-15, bool hermitian = false)
		{
			return input.pinverse(rcond, hermitian);
		}

		[Obsolete("torch.qr() is deprecated in favor of torch.linalg.qr() and will be removed in a future PyTorch release.", true)]
		public static Tensor qr(Tensor input, bool some = true)
		{
			throw new NotImplementedException();
		}

		[Obsolete("torch.qr() is deprecated in favor of torch.linalg.svd() and will be removed in a future PyTorch release.", true)]
		public static Tensor svd(Tensor input, bool some = true, bool compute_uv = true)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static Tensor svd_lowrank(Tensor A, int q = 6, int niter = 2, Tensor? M = null)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static Tensor pca_lowrank(Tensor A, int q = 6, bool center = true, int niter = 2)
		{
			throw new NotImplementedException();
		}

		[Obsolete("torch.symeig() is deprecated in favor of torch.linalg.eigh() and will be removed in a future PyTorch release", true)]
		public static Tensor symeig(Tensor input, bool eigenvectors = false, bool upper = true)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		private static Tensor lobpcg(Tensor A, int k = 1, Tensor? B = null, Tensor? X = null, int? n = null, Tensor? iK = null, int? niter = null, float? tol = null, bool largest = true, LobpcgMethod method = LobpcgMethod.ortho, Action? tracker = null, IDictionary<string, string>? ortho_iparams = null, IDictionary<string, string>? ortho_fparams = null, IDictionary<string, string>? ortho_bparams = null)
		{
			throw new NotImplementedException();
		}

		public static Tensor softmax(Tensor input, int dim, ScalarType? dtype = null)
		{
			return special.softmax(input, dim, dtype);
		}

		public static Tensor trapz(Tensor y, Tensor x, long dim = -1L)
		{
			return trapezoid(y, x, dim);
		}

		public static Tensor trapz(Tensor y, double dx = 1.0, long dim = -1L)
		{
			return trapezoid(y, dx, dim);
		}

		public static Tensor trapezoid(Tensor y, Tensor x, long dim = -1L)
		{
			return y.trapezoid(x, dim);
		}

		public static Tensor trapezoid(Tensor y, double dx = 1.0, long dim = -1L)
		{
			return y.trapezoid(dx, dim);
		}

		public static Tensor cumulative_trapezoid(Tensor y, Tensor x, long dim = -1L)
		{
			return y.cumulative_trapezoid(x, dim);
		}

		public static Tensor cumulative_trapezoid(Tensor y, double dx = 1.0, long dim = -1L)
		{
			return y.cumulative_trapezoid(dx, dim);
		}

		[Obsolete("torch.triangular_solve() is deprecated in favor of torch.linalg.solve_triangular() and will be removed in a future PyTorch release.", true)]
		private static Tensor triangular_solve(Tensor b, Tensor A, bool upper = true, bool transpose = false, bool unitriangular = false)
		{
			throw new NotImplementedException();
		}

		public static Tensor vdot(Tensor input, Tensor target)
		{
			return input.vdot(target);
		}

		public static bool allclose(Tensor tensor, Tensor target, double rtol = 1E-05, double atol = 1E-08, bool equal_nan = false)
		{
			return tensor.allclose(target, rtol, atol, equal_nan);
		}

		public static Tensor argsort(Tensor input, long dim = -1L, bool descending = false)
		{
			return input.argsort(dim, descending);
		}

		public static Tensor eq(Tensor left, Tensor right)
		{
			return left.eq(right);
		}

		public static Tensor equal(Tensor tensor, Tensor target)
		{
			return tensor.equal(target);
		}

		public static Tensor ge(Tensor left, Tensor right)
		{
			return left.ge(right);
		}

		public static Tensor greater_equal(Tensor tensor, Tensor target)
		{
			return tensor.greater_equal(target);
		}

		public static Tensor gt(Tensor left, Tensor right)
		{
			return left.gt(right);
		}

		public static Tensor greater(Tensor tensor, Tensor target)
		{
			return tensor.greater(target);
		}

		public static Tensor isclose(Tensor tensor, Tensor other, double rtol = 1E-05, double atol = 1E-08, bool nanEqual = false)
		{
			return tensor.isclose(other, rtol, atol, nanEqual);
		}

		public static Tensor isfinite(Tensor tensor)
		{
			return tensor.isfinite();
		}

		public static Tensor isin(Tensor tensor, Tensor test_elements, bool assumeUnique = false, bool invert = false)
		{
			return tensor.isin(test_elements, assumeUnique, invert);
		}

		public static Tensor isinf(Tensor tensor)
		{
			return tensor.isinf();
		}

		public static Tensor isposinf(Tensor tensor)
		{
			return tensor.isposinf();
		}

		public static Tensor isneginf(Tensor tensor)
		{
			return tensor.isneginf();
		}

		public static Tensor isnan(Tensor input)
		{
			return input.isnan();
		}

		public static Tensor isreal(Tensor tensor)
		{
			return tensor.isreal();
		}

		public static (Tensor values, Tensor indices) kthvalue(Tensor input, long k, long? dim, bool keepdim = false)
		{
			return input.kthvalue(k, dim, keepdim);
		}

		public static Tensor le(Tensor left, Tensor right)
		{
			return left.le(right);
		}

		public static Tensor less_equal(Tensor tensor, Tensor target)
		{
			return tensor.less_equal(target);
		}

		public static Tensor lt(Tensor left, Tensor right)
		{
			return left.lt(right);
		}

		public static Tensor less(Tensor tensor, Tensor target)
		{
			return tensor.less(target);
		}

		public static Tensor maximum(Tensor input, Tensor other)
		{
			return input.maximum(other);
		}

		public static Tensor minimum(Tensor input, Tensor other)
		{
			return input.minimum(other);
		}

		public static Tensor fmax(Tensor input, Tensor other)
		{
			return input.fmax(other);
		}

		public static Tensor fmin(Tensor input, Tensor other)
		{
			return input.fmin(other);
		}

		public static Tensor ne(Tensor left, Tensor right)
		{
			return left.ne(right);
		}

		public static Tensor not_equal(Tensor tensor, Tensor target)
		{
			return tensor.not_equal(target);
		}

		public static (Tensor values, Tensor indices) sort(Tensor input, long dim = -1L, bool descending = false, bool stable = false)
		{
			return input.sort(dim, descending, stable);
		}

		public static Tensor searchsorted(Tensor sorted_sequence, Tensor values, bool out_int32 = false, bool right = false, Tensor sorter = null)
		{
			IntPtr intPtr = NativeMethods.THSTensor_searchsorted_t(sorted_sequence.Handle, values.Handle, out_int32, right, sorter?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor searchsorted(Tensor sorted_sequence, Scalar values, bool out_int32, bool right, Tensor sorter)
		{
			IntPtr intPtr = NativeMethods.THSTensor_searchsorted_s(sorted_sequence.Handle, values.Handle, out_int32, right, sorter?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static (Tensor hist, Tensor bin_edges) histogram(Tensor input, HistogramBinSelector bins, (double min, double max)? range = null, bool density = false)
		{
			return Histogram.histogram(input, bins, range, density);
		}

		public static (Tensor hist, Tensor bin_edges) histogram(Tensor input, Tensor bins, Tensor weight = null, bool density = false)
		{
			IntPtr r_bin_edges;
			IntPtr intPtr = NativeMethods.THSTensor_histogram_t(input.Handle, bins.Handle, weight?.Handle ?? IntPtr.Zero, density, out r_bin_edges);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			if (r_bin_edges == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return (hist: new Tensor(intPtr), bin_edges: new Tensor(r_bin_edges));
		}

		public unsafe static (Tensor hist, Tensor bin_edges) histogram(Tensor input, long bins, (double min, double max)? range = null, Tensor weight = null, bool density = false)
		{
			double[] array = Array.Empty<double>();
			if (range.HasValue)
			{
				array = new double[2]
				{
					range.Value.min,
					range.Value.max
				};
			}
			fixed (double* ptr = array)
			{
				IntPtr r_bin_edges;
				IntPtr intPtr = ((array == Array.Empty<double>()) ? NativeMethods.THSTensor_histogram_i(input.Handle, bins, IntPtr.Zero, 0, weight?.Handle ?? IntPtr.Zero, density, out r_bin_edges) : NativeMethods.THSTensor_histogram_i(input.Handle, bins, (IntPtr)ptr, array.Length, weight?.Handle ?? IntPtr.Zero, density, out r_bin_edges));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (r_bin_edges == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return (hist: new Tensor(intPtr), bin_edges: new Tensor(r_bin_edges));
			}
		}

		public static (Tensor hist, Tensor bin_edges) histogram(Tensor input, Tensor bins, out (Tensor hist, Tensor bin_edges) out_tensor)
		{
			return histogram(input, bins, null, density: false, out out_tensor);
		}

		public static (Tensor hist, Tensor bin_edges) histogram(Tensor input, Tensor bins, Tensor weight, bool density, out (Tensor hist, Tensor bin_edges) out_tensor)
		{
			IntPtr hist;
			IntPtr bin_edges;
			IntPtr r_bin_edges;
			IntPtr intPtr = NativeMethods.THSTensor_histogram_out_t(input.Handle, bins.Handle, weight?.Handle ?? IntPtr.Zero, density, out hist, out bin_edges, out r_bin_edges);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			if (hist == IntPtr.Zero)
			{
				CheckForErrors();
			}
			if (bin_edges == IntPtr.Zero)
			{
				CheckForErrors();
			}
			if (r_bin_edges == IntPtr.Zero)
			{
				CheckForErrors();
			}
			out_tensor = (hist: new Tensor(hist), bin_edges: new Tensor(bin_edges));
			return (hist: new Tensor(intPtr), bin_edges: new Tensor(r_bin_edges));
		}

		public static (Tensor hist, Tensor bin_edges) histogram(Tensor input, long bins, out (Tensor hist, Tensor bin_edges) out_tensor)
		{
			return histogram(input, bins, null, null, density: false, out out_tensor);
		}

		public static (Tensor hist, Tensor bin_edges) histogram(Tensor input, long bins, (double min, double max)? range, out (Tensor hist, Tensor bin_edges) out_tensor)
		{
			return histogram(input, bins, range, null, density: false, out out_tensor);
		}

		public unsafe static (Tensor hist, Tensor bin_edges) histogram(Tensor input, long bins, (double min, double max)? range, Tensor weight, bool density, out (Tensor hist, Tensor bin_edges) out_tensor)
		{
			double[] array = Array.Empty<double>();
			if (range.HasValue)
			{
				array = new double[2]
				{
					range.Value.min,
					range.Value.max
				};
			}
			fixed (double* ptr = array)
			{
				IntPtr hist;
				IntPtr bin_edges;
				IntPtr r_bin_edges;
				IntPtr intPtr = ((array == Array.Empty<double>()) ? NativeMethods.THSTensor_histogram_out_i(input.Handle, bins, IntPtr.Zero, 0, weight?.Handle ?? IntPtr.Zero, density, out hist, out bin_edges, out r_bin_edges) : NativeMethods.THSTensor_histogram_out_i(input.Handle, bins, (IntPtr)ptr, array.Length, weight?.Handle ?? IntPtr.Zero, density, out hist, out bin_edges, out r_bin_edges));
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (hist == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (bin_edges == IntPtr.Zero)
				{
					CheckForErrors();
				}
				if (r_bin_edges == IntPtr.Zero)
				{
					CheckForErrors();
				}
				out_tensor = (hist: new Tensor(hist), bin_edges: new Tensor(bin_edges));
				return (hist: new Tensor(intPtr), bin_edges: new Tensor(r_bin_edges));
			}
		}

		public static (Tensor values, Tensor indices) topk(Tensor tensor, int k, int dim = -1, bool largest = true, bool sorted = true)
		{
			return tensor.topk(k, dim, largest, sorted);
		}

		public static Tensor msort(Tensor tensor)
		{
			return tensor.msort();
		}

		public static Tensor cholesky(Tensor input, bool upper)
		{
			return input.cholesky(upper);
		}

		public static Tensor norm(Tensor input)
		{
			return input.norm();
		}

		public static Tensor concatenate(IList<Tensor> tensors, long axis = 0L)
		{
			return cat(tensors, axis);
		}

		public static Tensor concatenate(Tensor[] tensors, long axis = 0L)
		{
			return cat(tensors, axis);
		}

		public static Tensor concatenate(ReadOnlySpan<Tensor> tensors, long axis = 0L)
		{
			return cat(tensors, axis);
		}

		public static Tensor squeeze(Tensor input, long? dim = null)
		{
			return input.squeeze(dim);
		}

		public static Tensor squeeze_(Tensor input, long? dim = null)
		{
			return input.squeeze_(dim);
		}

		public static Tensor column_stack(IList<Tensor> tensors)
		{
			return column_stack(tensors.ToHandleArray());
		}

		public static Tensor column_stack(params Tensor[] tensors)
		{
			return column_stack(tensors.ToHandleArray());
		}

		public static Tensor column_stack(ReadOnlySpan<Tensor> tensors)
		{
			return column_stack(tensors.ToHandleArray());
		}

		private static Tensor column_stack(IntPtr[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_column_stack(pinnedArray.CreateArray(tensors), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor row_stack(IList<Tensor> tensors)
		{
			return row_stack(tensors.ToHandleArray());
		}

		public static Tensor row_stack(params Tensor[] tensors)
		{
			return row_stack(tensors.ToHandleArray());
		}

		public static Tensor row_stack(ReadOnlySpan<Tensor> tensors)
		{
			return row_stack(tensors.ToHandleArray());
		}

		private static Tensor row_stack(IntPtr[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_row_stack(pinnedArray.CreateArray(tensors), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor[] unbind(Tensor tensor, int dim = 0)
		{
			return tensor.unbind(dim);
		}

		public static Tensor scatter_add_(Tensor input, long dim, Tensor index, Tensor src)
		{
			return input.scatter_add_(dim, index, src);
		}

		public static Tensor clamp_max(Tensor input, Scalar max)
		{
			return input.clamp_max(max);
		}

		public static Tensor clamp_max_(Tensor input, Scalar max)
		{
			return input.clamp_max(max);
		}

		public static Tensor clamp_min(Tensor input, Scalar min)
		{
			return input.clamp_min(min);
		}

		public static Tensor clamp_min_(Tensor input, Scalar min)
		{
			return input.clamp_min(min);
		}

		public static Tensor unflatten(Tensor input, long dim, params long[] sizes)
		{
			return input.unflatten(dim, sizes);
		}

		public static Tensor unflatten(Tensor input, long dim, Size sizes)
		{
			return input.unflatten(dim, sizes.Shape);
		}

		public static Tensor _standard_gamma(Tensor input, Generator? generator = null)
		{
			IntPtr intPtr = NativeMethods.THSTensor_standard_gamma_(input.Handle, generator?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor _sample_dirichlet(Tensor input, Generator? generator = null)
		{
			IntPtr intPtr = NativeMethods.THSTensor_sample_dirichlet_(input.Handle, generator?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor index_fill(Tensor input, long dim, Tensor index, Scalar value)
		{
			return input.index_fill(dim, index, value);
		}

		public static Tensor index_fill_(Tensor input, long dim, Tensor index, Scalar value)
		{
			return input.index_fill_(dim, index, value);
		}

		public static bool is_conj(Tensor input)
		{
			return input.is_conj();
		}

		public static (Tensor std, Tensor mean) std_mean(Tensor input, bool unbiased = true)
		{
			return input.std_mean(unbiased);
		}

		public static Tensor rand_out(Tensor input, params long[] sizes)
		{
			return input.randn_out(sizes);
		}

		public static Tensor randint_out(Tensor input, long high, long[] sizes)
		{
			return input.randint_out(high, sizes);
		}

		public static Tensor randn_like(Tensor input, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return input.randn_like(dtype, device, requires_grad);
		}

		public static Tensor randint_like(Tensor input, long low, long high, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return input.randint_like(low, high, dtype, device, requires_grad);
		}

		[Obsolete("This doesn't exist in PyTorch.")]
		public static Tensor randperm_out(Tensor input, long n)
		{
			return randperm(n, input);
		}

		public static Tensor binomial(Tensor count, Tensor probs, Generator? generator = null)
		{
			return count.binomial(probs, generator);
		}

		public static Tensor adjoint(Tensor input)
		{
			return input.adjoint();
		}

		public static Tensor argwhere(Tensor input)
		{
			return input.argwhere();
		}

		public static Tensor cat(IList<Tensor> tensors, long dim = 0L)
		{
			int count = tensors.Count;
			if (count > 0)
			{
				if (count == 1)
				{
					return tensors[0].alias();
				}
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = NativeMethods.THSTensor_cat(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}
			throw new ArgumentException("tensors");
		}

		public static Tensor cat(Tensor[] tensors, long dim = 0L)
		{
			return cat((ReadOnlySpan<Tensor>)tensors, dim);
		}

		public static Tensor cat(ReadOnlySpan<Tensor> tensors, long dim = 0L)
		{
			int length = tensors.Length;
			if (length > 0)
			{
				if (length == 1)
				{
					return tensors[0].alias();
				}
				using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
				IntPtr intPtr = NativeMethods.THSTensor_cat(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length, dim);
				if (intPtr == IntPtr.Zero)
				{
					CheckForErrors();
				}
				return new Tensor(intPtr);
			}
			throw new ArgumentException("tensors");
		}

		public static Tensor concat(IList<Tensor> tensors, long dim = 0L)
		{
			return cat(tensors, dim);
		}

		public static Tensor concat(Tensor[] tensors, long dim = 0L)
		{
			return cat(tensors, dim);
		}

		public static Tensor concat(ReadOnlySpan<Tensor> tensors, long dim = 0L)
		{
			return cat(tensors, dim);
		}

		public static Tensor conj(Tensor input)
		{
			return input.conj();
		}

		public static Tensor[] chunk(Tensor input, long chunks, long dim = 0L)
		{
			return input.chunk(chunks, dim);
		}

		public static Tensor[] dsplit(Tensor input, Tensor indices_or_sections)
		{
			return input.dsplit(indices_or_sections);
		}

		public static Tensor[] dsplit(Tensor input, long size)
		{
			return input.dsplit(size);
		}

		public static Tensor[] dsplit(Tensor input, long[] indices_or_sections)
		{
			return input.dsplit(indices_or_sections);
		}

		public static Tensor[] dsplit(Tensor input, (long, long) indices_or_sections)
		{
			return input.dsplit(indices_or_sections);
		}

		public static Tensor[] dsplit(Tensor input, (long, long, long) indices_or_sections)
		{
			return input.dsplit(indices_or_sections);
		}

		public static Tensor[] dsplit(Tensor input, (long, long, long, long) indices_or_sections)
		{
			return input.dsplit(indices_or_sections);
		}

		public static Tensor dstack(params Tensor[] tensors)
		{
			return dstack(tensors.ToHandleArray());
		}

		public static Tensor dstack(IList<Tensor> tensors)
		{
			return dstack(tensors.ToHandleArray());
		}

		public static Tensor dstack(ReadOnlySpan<Tensor> tensors)
		{
			return dstack(tensors.ToHandleArray());
		}

		public static Tensor dstack(IEnumerable<Tensor> tensors)
		{
			return dstack(tensors.ToHandleArray());
		}

		private static Tensor dstack(IntPtr[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_dstack(pinnedArray.CreateArray(tensors), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor gather(Tensor input, long dim, Tensor index)
		{
			return input.gather(dim, index);
		}

		public static Tensor gather(Tensor input, long dim, Tensor index, bool sparse_grad = false)
		{
			return input.gather(dim, index);
		}

		public static Tensor[] hsplit(Tensor input, Tensor indices_or_sections)
		{
			return input.hsplit(indices_or_sections);
		}

		public static Tensor[] hsplit(Tensor input, long indices_or_sections)
		{
			return input.hsplit(indices_or_sections);
		}

		public static Tensor[] hsplit(Tensor input, long[] indices_or_sections)
		{
			return input.hsplit(indices_or_sections);
		}

		public static Tensor[] hsplit(Tensor input, (long, long) indices_or_sections)
		{
			return input.hsplit(indices_or_sections.Item1, indices_or_sections.Item2);
		}

		public static Tensor[] hsplit(Tensor input, (long, long, long) indices_or_sections)
		{
			return input.hsplit(indices_or_sections.Item1, indices_or_sections.Item2, indices_or_sections.Item3);
		}

		public static Tensor[] hsplit(Tensor input, (long, long, long, long) indices_or_sections)
		{
			return input.hsplit(indices_or_sections.Item1, indices_or_sections.Item2, indices_or_sections.Item3, indices_or_sections.Item4);
		}

		public static Tensor hstack(IList<Tensor> tensors)
		{
			return hstack(tensors.ToHandleArray());
		}

		public static Tensor hstack(params Tensor[] tensors)
		{
			return hstack(tensors.ToHandleArray());
		}

		public static Tensor hstack(IEnumerable<Tensor> tensors)
		{
			return hstack(tensors.ToHandleArray());
		}

		public static Tensor hstack(ReadOnlySpan<Tensor> tensors)
		{
			return hstack(tensors.ToHandleArray());
		}

		private static Tensor hstack(IntPtr[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_hstack(pinnedArray.CreateArray(tensors), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor index_add(Tensor input, long dim, Tensor index, Tensor source, Scalar alpha)
		{
			return input.index_add(dim, index, source, alpha);
		}

		public static Tensor index_add_(Tensor input, long dim, Tensor index, Tensor source, Scalar alpha)
		{
			return input.index_add_(dim, index, source, alpha);
		}

		public static Tensor index_copy(Tensor input, long dim, Tensor index, Tensor source)
		{
			return input.index_copy(dim, index, source);
		}

		public static Tensor index_copy_(Tensor input, long dim, Tensor index, Tensor source)
		{
			return input.index_copy_(dim, index, source);
		}

		[Obsolete("not implemented", true)]
		public static Tensor index_reduce(Tensor input, long dim, Tensor index, Tensor source, Reduce reduce, bool include_self = true)
		{
			throw new NotImplementedException();
		}

		public static Tensor index_select(Tensor input, long dim, Tensor index)
		{
			return input.index_select(dim, index);
		}

		public static Tensor masked_select(Tensor input, Tensor mask)
		{
			return input.masked_select(mask);
		}

		public static Tensor movedim(Tensor input, long source, long destination)
		{
			return input.movedim(new long[1] { source }, new long[1] { destination });
		}

		private static Tensor movedim(Tensor input, (long, long) source, (long, long) destination)
		{
			return input.movedim(new long[2] { source.Item1, source.Item2 }, new long[2] { destination.Item1, destination.Item2 });
		}

		private static Tensor movedim(Tensor input, (long, long, long) source, (long, long, long) destination)
		{
			return input.movedim(new long[3] { source.Item1, source.Item2, source.Item3 }, new long[3] { destination.Item1, destination.Item2, destination.Item3 });
		}

		private static Tensor movedim(Tensor input, (long, long, long, long) source, (long, long, long, long) destination)
		{
			return input.movedim(new long[4] { source.Item1, source.Item2, source.Item3, source.Item4 }, new long[4] { destination.Item1, destination.Item2, destination.Item3, destination.Item4 });
		}

		public static Tensor movedim(Tensor input, long[] source, long[] destination)
		{
			return input.movedim(source, destination);
		}

		public static Tensor moveaxis(Tensor input, long source, long destination)
		{
			return input.moveaxis(new long[1] { source }, new long[1] { destination });
		}

		public static Tensor moveaxis(Tensor input, (long, long) source, (long, long) destination)
		{
			return input.moveaxis(new long[2] { source.Item1, source.Item2 }, new long[2] { destination.Item1, destination.Item2 });
		}

		public static Tensor moveaxis(Tensor input, (long, long, long) source, (long, long, long) destination)
		{
			return input.moveaxis(new long[3] { source.Item1, source.Item2, source.Item3 }, new long[3] { destination.Item1, destination.Item2, destination.Item3 });
		}

		public static Tensor moveaxis(Tensor input, (long, long, long, long) source, (long, long, long, long) destination)
		{
			return input.moveaxis(new long[4] { source.Item1, source.Item2, source.Item3, source.Item4 }, new long[4] { destination.Item1, destination.Item2, destination.Item3, destination.Item4 });
		}

		public static Tensor moveaxis(Tensor input, long[] source, long[] destination)
		{
			return input.moveaxis(source, destination);
		}

		public static Tensor narrow(Tensor input, long dim, long start, long length)
		{
			return input.narrow(dim, start, length);
		}

		public static Tensor nonzero(Tensor input)
		{
			return input.nonzero();
		}

		public static Tensor permute(Tensor input, params long[] permutation)
		{
			return input.permute(permutation);
		}

		public static Tensor reshape(Tensor input, params long[] shape)
		{
			return input.reshape(shape);
		}

		public static Tensor select(Tensor input, long dim, long index)
		{
			return input.select(dim, index);
		}

		public static Tensor scatter(Tensor input, long dim, Tensor index, Tensor src)
		{
			return input.scatter(dim, index, src);
		}

		public static Tensor scatter_(Tensor input, long dim, Tensor index, Tensor src)
		{
			return input.scatter_(dim, index, src);
		}

		public static Tensor diagonal_scatter(Tensor input, Tensor src, long offset = 0L, long dim1 = 0L, long dim2 = 1L)
		{
			return input.diagonal_scatter(src, offset, dim1, dim2);
		}

		public static Tensor select_scatter(Tensor input, Tensor src, long dim, long index)
		{
			return input.select_scatter(src, dim, index);
		}

		public static Tensor slice_scatter(Tensor input, Tensor src, long dim = 0L, long? start = null, long? end = null, long step = 1L)
		{
			return input.slice_scatter(src, dim, start, end, step);
		}

		public static Tensor scatter_add(Tensor input, long dim, Tensor index, Tensor src)
		{
			return input.scatter_add(dim, index, src);
		}

		[Obsolete("not implemented", true)]
		private static Tensor scatter_reduce(Tensor input, long dim, Tensor index, Tensor src, Reduce reduce, bool include_self = true)
		{
			throw new NotImplementedException();
		}

		public static Tensor[] split(Tensor tensor, long[] split_size_or_sections, long dim = 0L)
		{
			return tensor.split(split_size_or_sections, dim);
		}

		public static Tensor stack(IEnumerable<Tensor> tensors, long dim = 0L)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_stack(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length, dim);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor swapaxes(Tensor input, long axis0, long axis1)
		{
			return input.swapaxes(axis0, axis1);
		}

		public static Tensor swapdims(Tensor input, long dim0, long dim1)
		{
			return input.swapdims(dim0, dim1);
		}

		public static Tensor t(Tensor input)
		{
			return input.t();
		}

		public static Tensor take(Tensor input, Tensor index)
		{
			return input.take(index);
		}

		public static Tensor take_along_dim(Tensor input, Tensor indices, long dim = 0L)
		{
			return input.take_along_dim(indices, dim);
		}

		public static Tensor take_along_dim(Tensor input, IEnumerable<long> indices, long dim = 0L)
		{
			return input.take_along_dim(indices, dim);
		}

		public static Tensor[] tensor_split(Tensor input, long indices_or_sections, long dim = 0L)
		{
			return input.tensor_split(indices_or_sections, dim);
		}

		public static Tensor[] tensor_split(Tensor input, long[] indices_or_sections, long dim = 0L)
		{
			return input.tensor_split(indices_or_sections, dim);
		}

		public static Tensor[] tensor_split(Tensor input, Tensor indices_or_sections, long dim = 0L)
		{
			return input.tensor_split(indices_or_sections, dim);
		}

		public static Tensor tile(Tensor input, long[] dims)
		{
			return input.tile(dims);
		}

		public static Tensor transpose(Tensor input, long dim0, long dim1)
		{
			return input.transpose(dim0, dim1);
		}

		public static Tensor[] unbind(Tensor input, long dim = 0L)
		{
			return input.unbind(dim);
		}

		public static Tensor unsqueeze(Tensor input, long dim)
		{
			return input.unsqueeze(dim);
		}

		public static Tensor unsqueeze_(Tensor input, long dim)
		{
			return input.unsqueeze_(dim);
		}

		public static Tensor[] vsplit(Tensor input, long[] indices_or_sections)
		{
			return input.vsplit(indices_or_sections);
		}

		public static Tensor vstack(IList<Tensor> tensors)
		{
			return vstack(tensors.ToHandleArray());
		}

		public static Tensor vstack(Tensor[] tensors)
		{
			return vstack(tensors.ToHandleArray());
		}

		public static Tensor vstack(ReadOnlySpan<Tensor> tensors)
		{
			return vstack(tensors.ToHandleArray());
		}

		private static Tensor vstack(IntPtr[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_vstack(pinnedArray.CreateArray(tensors), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor where(Tensor condition, Tensor x, Tensor y)
		{
			return x.where(condition, y);
		}

		public static Tensor[] where(Tensor condition)
		{
			if (condition.dtype != ScalarType.Bool)
			{
				throw new ArgumentException("The condition to 'where' must be a boolean tensor.");
			}
			IntPtr[] array;
			using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
			{
				NativeMethods.THSTensor_where_list(condition.Handle, pinnedArray.CreateArray);
				CheckForErrors();
				array = pinnedArray.Array;
			}
			return array.Select((IntPtr x) => new Tensor(x)).ToArray();
		}

		public static IDisposable no_grad()
		{
			return new AutoGradMode(enabled: false);
		}

		public static IDisposable enable_grad(bool enabled = true)
		{
			return new AutoGradMode(enabled);
		}

		public static IDisposable set_grad_enabled(bool mode = true)
		{
			return new AutoGradMode(mode);
		}

		public static bool is_grad_enabled()
		{
			return AutoGradMode.IsEnabled;
		}

		public static IDisposable inference_mode(bool mode = true)
		{
			return new InferenceMode(mode);
		}

		public static bool is_inference_mode_enabled()
		{
			return InferenceMode.IsEnabled;
		}

		public static IEnumerable<Tensor> atleast_1d(params Tensor[] input)
		{
			return input.Select((Tensor t) => t.atleast_1d());
		}

		public static IEnumerable<Tensor> atleast_2d(params Tensor[] input)
		{
			return input.Select((Tensor t) => t.atleast_2d());
		}

		public static IEnumerable<Tensor> atleast_3d(params Tensor[] input)
		{
			return input.Select((Tensor t) => t.atleast_3d());
		}

		public static Tensor bincount(Tensor input, Tensor? weights = null, long minlength = 0L)
		{
			return input.bincount(weights, minlength);
		}

		public static Tensor block_diag(params Tensor[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_block_diag(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static IList<Tensor> broadcast_tensors(params Tensor[] tensors)
		{
			if (tensors.Length == 0)
			{
				throw new ArgumentException("tensors");
			}
			if (tensors.Length == 1)
			{
				return new Tensor[1] { tensors[0].alias() };
			}
			IntPtr[] array;
			using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
			{
				using PinnedArray<IntPtr> pinnedArray2 = new PinnedArray<IntPtr>();
				NativeMethods.THSTensor_broadcast_tensors(pinnedArray2.CreateArray(tensors.ToHandleArray()), tensors.Length, pinnedArray.CreateArray);
				CheckForErrors();
				array = pinnedArray.Array;
			}
			return array.Select((IntPtr x) => new Tensor(x)).ToList();
		}

		public static Tensor broadcast_to(Tensor input, params long[] shape)
		{
			return input.broadcast_to(shape);
		}

		public static Size broadcast_shapes(params long[][] shapes)
		{
			int num = 0;
			long[][] array = shapes;
			for (int i = 0; i < array.Length; i++)
			{
				int num2 = array[i].Length;
				if (num2 > num)
				{
					num = num2;
				}
			}
			long[] array2 = Enumerable.Repeat(1L, num).ToArray();
			array = shapes;
			foreach (long[] array3 in array)
			{
				for (int num3 = array3.Length - 1; num3 >= 0; num3--)
				{
					if (array3.Length != 0 && array3[num3] != 1 && array3[num3] != array2[num3])
					{
						if (array2[num3] != 1)
						{
							throw new ArgumentException("Shape mismatch: objects cannot be broadcast to a single shape");
						}
						array2[num3] = array3[num3];
					}
				}
			}
			return array2;
		}

		public static Tensor bucketize(Tensor input, Tensor boundaries, bool outInt32 = false, bool right = false)
		{
			return input.bucketize(boundaries, outInt32, right);
		}

		public static Tensor cartesian_prod(IList<Tensor> tensors)
		{
			return cartesian_prod(tensors.ToHandleArray());
		}

		public static Tensor cartesian_prod(params Tensor[] tensors)
		{
			return cartesian_prod(tensors.ToHandleArray());
		}

		public static Tensor cartesian_prod(ReadOnlySpan<Tensor> tensors)
		{
			return cartesian_prod(tensors.ToHandleArray());
		}

		private static Tensor cartesian_prod(IntPtr[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr intPtr = NativeMethods.THSTensor_cartesian_prod(pinnedArray.CreateArray(tensors), pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor cdist(Tensor x1, Tensor x2, double p = 2.0, compute_mode compute_mode = compute_mode.use_mm_for_euclid_dist_if_necessary)
		{
			if (p < 0.0)
			{
				throw new ArgumentException("p must be non-negative");
			}
			IntPtr intPtr = NativeMethods.THSTensor_cdist(x1.Handle, x2.Handle, p, (long)compute_mode);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor clone(Tensor input)
		{
			return input.clone();
		}

		public static Tensor combinations(Tensor input, int r = 2, bool with_replacement = false)
		{
			if (input.ndim != 1)
			{
				throw new ArgumentException($"Expected a 1D vector, but got one with {input.ndim} dimensions.");
			}
			if (r < 0)
			{
				throw new ArgumentException("r must be non-negative");
			}
			IntPtr intPtr = NativeMethods.THSTensor_combinations(input.Handle, r, with_replacement);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor corrcoef(Tensor input)
		{
			return input.corrcoef();
		}

		public static Tensor cov(Tensor input, long correction = 1L, Tensor? fweights = null, Tensor? aweights = null)
		{
			return input.cov(correction, fweights, aweights);
		}

		public static Tensor cross(Tensor input, Scalar other, long dim = 0L)
		{
			return input.cross(other, dim);
		}

		public static (Tensor values, Tensor indices) cummax(Tensor input, long dim)
		{
			return input.cummax(dim);
		}

		public static (Tensor values, Tensor indices) cummin(Tensor input, long dim)
		{
			return input.cummin(dim);
		}

		public static Tensor cumprod(Tensor input, long dim, ScalarType? dtype = null)
		{
			return input.cumprod(dim, dtype);
		}

		public static Tensor cumsum(Tensor input, long dim, ScalarType? type = null)
		{
			return input.cumsum(dim, type);
		}

		public static Tensor diag(Tensor input, long diagonal = 0L)
		{
			return input.diag(diagonal);
		}

		public static Tensor diag_embed(Tensor input, long offset = 0L, long dim1 = -2L, long dim2 = -1L)
		{
			return input.diag_embed(offset, dim1, dim2);
		}

		public static Tensor diagflat(Tensor input, long offset = 0L)
		{
			return input.diagflat(offset);
		}

		public static Tensor diagonal(Tensor input, long offset = 0L, long dim1 = 0L, long dim2 = 1L)
		{
			return input.diagonal(offset, dim1, dim2);
		}

		public static Tensor diff(Tensor input, long n = 1L, long dim = -1L, Tensor? prepend = null, Tensor? append = null)
		{
			return input.diff(n, dim, prepend, append);
		}

		public static Tensor einsum(string equation, params Tensor[] tensors)
		{
			using PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>();
			IntPtr tensors2 = pinnedArray.CreateArray(tensors.ToHandleArray());
			IntPtr intPtr = NativeMethods.THSTensor_einsum(equation, tensors2, pinnedArray.Array.Length);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor flatten(Tensor input, long start_dim = 0L, long end_dim = -1L)
		{
			return input.flatten(start_dim, end_dim);
		}

		public static Tensor flip(Tensor input, params long[] dims)
		{
			return input.flip(dims);
		}

		public static Tensor fliplr(Tensor input)
		{
			return input.fliplr();
		}

		public static Tensor flipud(Tensor input)
		{
			return input.flipud();
		}

		public static Tensor kron(Tensor input, Tensor other)
		{
			return input.kron(other);
		}

		public static Tensor rot90(Tensor input, long k = 1L, (long, long)? dims = null)
		{
			return input.rot90(k, dims);
		}

		public static Tensor gcd(Tensor left, Tensor right)
		{
			return left.gcd(right);
		}

		public static Tensor gcd_(Tensor left, Tensor right)
		{
			return left.gcd_(right);
		}

		public static Tensor histc(Tensor input, long bins = 100L, long min = 0L, long max = 0L)
		{
			return input.histc(bins, min, max);
		}

		[Obsolete("not implemented", true)]
		private static Tensor histogram(Tensor input, long bins, (float min, float max)? range = null, Tensor? weight = null, bool density = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		private static Tensor histogram(Tensor input, long[] bins, (float min, float max)? range = null, Tensor? weight = null, bool density = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		private static Tensor histogram(Tensor input, Tensor[] bins, (float min, float max)? range = null, Tensor? weight = null, bool density = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		private static (Tensor hist_values, Tensor[] edges) histogramdd(Tensor input, long bins, (float min, float max)? range = null, Tensor? weight = null, bool density = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		private static (Tensor hist_values, Tensor[] edges) histogramdd(Tensor input, long[] bins, (float min, float max)? range = null, Tensor? weight = null, bool density = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		private static (Tensor hist_values, Tensor[] edges) histogramdd(Tensor input, Tensor[] bins, (float min, float max)? range = null, Tensor? weight = null, bool density = false)
		{
			throw new NotImplementedException();
		}

		private static IEnumerable<Tensor> meshgrid(IEnumerable<Tensor> tensors, indexing indexing = indexing.ij)
		{
			return meshgrid(tensors, indexing switch
			{
				indexing.ij => "ij", 
				indexing.xy => "xy", 
				_ => throw new ArgumentOutOfRangeException(), 
			});
		}

		public static Tensor[] meshgrid(IEnumerable<Tensor> tensors, string indexing = "ij")
		{
			IntPtr[] array;
			using (PinnedArray<IntPtr> pinnedArray = new PinnedArray<IntPtr>())
			{
				NativeMethods.THSTensor_meshgrid(pinnedArray.CreateArray(tensors.ToHandleArray()), pinnedArray.Array.Length, indexing, pinnedArray.CreateArray);
				CheckForErrors();
				array = pinnedArray.Array;
			}
			return array.Select((IntPtr x) => new Tensor(x)).ToArray();
		}

		public static Tensor lcm(Tensor input, Tensor other)
		{
			return input.lcm(other);
		}

		public static Tensor lcm_(Tensor input, Tensor other)
		{
			return input.lcm_(other);
		}

		public static Tensor logcumsumexp(Tensor input, long dim)
		{
			return input.logcumsumexp(dim);
		}

		public static Tensor ravel(Tensor input)
		{
			return input.ravel();
		}

		public static Tensor renorm(Tensor input, float p, long dim, float maxnorm)
		{
			return input.renorm(p, dim, maxnorm);
		}

		public static Tensor repeat_interleave(Tensor input, long repeats, long? dim = null, long? output_size = null)
		{
			return input.repeat_interleave(repeats, dim, output_size);
		}

		public static Tensor repeat_interleave(Tensor input, Tensor repeats, long? dim = null, long? output_size = null)
		{
			return input.repeat_interleave(repeats, dim, output_size);
		}

		public static Tensor roll(Tensor input, long shifts, long? dims = null)
		{
			return input.roll(shifts, dims);
		}

		public static Tensor roll(Tensor input, (long, long) shifts, (long, long) dims)
		{
			return input.roll(shifts, dims);
		}

		public static Tensor roll(Tensor input, (long, long, long) shifts, (long, long, long) dims)
		{
			return input.roll(shifts, dims);
		}

		public static Tensor roll(Tensor input, long[] shifts, long[] dims)
		{
			return input.roll(shifts, dims);
		}

		public static Tensor roll(Tensor input, long[] shifts)
		{
			return input.roll(shifts);
		}

		public static Tensor roll(Tensor input, ReadOnlySpan<long> shifts, ReadOnlySpan<long> dims = default(ReadOnlySpan<long>))
		{
			return input.roll(shifts, dims);
		}

		public static Tensor tensordot(Tensor a, Tensor b, long dims = 2L)
		{
			return a.tensordot(b, dims);
		}

		public static Tensor tensordot(Tensor a, Tensor b, long[] dims1, long[] dims2)
		{
			return a.tensordot(b, dims1, dims2);
		}

		public static Tensor tensordot(Tensor a, Tensor b, (long, long)[] dims)
		{
			return a.tensordot(b, dims);
		}

		public static Tensor trace(Tensor input)
		{
			return input.trace();
		}

		public static Tensor tril(Tensor input, long diagonal = 0L)
		{
			return input.tril(diagonal);
		}

		public static Tensor tril_(Tensor input, long diagonal = 0L)
		{
			return input.tril_(diagonal);
		}

		public static Tensor tril_indices(long row, long col, long offset = 0L, ScalarType dtype = ScalarType.Int64, Device? device = null)
		{
			if (!is_integral(dtype))
			{
				throw new ArgumentException("dtype must be integral.");
			}
			if (device == null)
			{
				device = CPU;
			}
			IntPtr intPtr = NativeMethods.THSTensor_tril_indices(row, col, offset, (sbyte)dtype, (int)device.type, device.index);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor triu(Tensor input, long diagonal = 0L)
		{
			return input.triu(diagonal);
		}

		public static Tensor triu_(Tensor input, long diagonal = 0L)
		{
			return input.triu_(diagonal);
		}

		public static Tensor triu_indices(long row, long col, long offset = 0L, ScalarType dtype = ScalarType.Int64, Device? device = null)
		{
			if (!is_integral(dtype))
			{
				throw new ArgumentException("dtype must be integral.");
			}
			if (device == null)
			{
				device = CPU;
			}
			IntPtr intPtr = NativeMethods.THSTensor_triu_indices(row, col, offset, (sbyte)dtype, (int)device.type, device.index);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor vander(Tensor x, long N = -1L, bool increasing = false)
		{
			return x.vander(N, increasing);
		}

		public static Tensor view_as_real(Tensor input)
		{
			return input.view_as_real();
		}

		public static Tensor view_as_complex(Tensor input)
		{
			return input.view_as_complex();
		}

		public static Tensor resolve_conj(Tensor input)
		{
			return input.resolve_conj();
		}

		public static Tensor resolve_neg(Tensor input)
		{
			return input.resolve_neg();
		}

		public static Tensor is_neg(Tensor input)
		{
			return input.is_neg();
		}

		public static int get_num_threads()
		{
			int num = NativeMethods.THSTorch_get_num_threads();
			if (num == -1)
			{
				CheckForErrors();
			}
			return num;
		}

		public static void set_num_threads(int num)
		{
			NativeMethods.THSTorch_set_num_threads(num);
			CheckForErrors();
		}

		public static int get_num_interop_threads()
		{
			int num = NativeMethods.THSTorch_get_num_interop_threads();
			if (num == -1)
			{
				CheckForErrors();
			}
			return num;
		}

		public static void set_num_interop_threads(int num)
		{
			NativeMethods.THSTorch_set_num_interop_threads(num);
			CheckForErrors();
		}

		public static Tensor abs(Tensor input)
		{
			return input.abs();
		}

		public static Tensor abs_(Tensor input)
		{
			return input.abs_();
		}

		public static Tensor absolute(Tensor input)
		{
			return input.absolute();
		}

		public static Tensor absolute_(Tensor input)
		{
			return input.absolute_();
		}

		public static Tensor acos(Tensor input)
		{
			return input.acos();
		}

		public static Tensor acos_(Tensor input)
		{
			return input.acos_();
		}

		public static Tensor arccos(Tensor input)
		{
			return input.arccos();
		}

		public static Tensor arccos_(Tensor input)
		{
			return input.arccos_();
		}

		public static Tensor acosh(Tensor input)
		{
			return input.acosh();
		}

		public static Tensor acosh_(Tensor input)
		{
			return input.acosh_();
		}

		public static Tensor arccosh(Tensor input)
		{
			return input.arccosh();
		}

		public static Tensor arccosh_(Tensor input)
		{
			return input.arccosh_();
		}

		public static Tensor add(Tensor left, Tensor right)
		{
			return left.add(right);
		}

		public static Tensor add(Tensor left, Scalar right)
		{
			return left.add(right);
		}

		public static Tensor add(Tensor left, Tensor right, Scalar alpha)
		{
			return left.add(right, alpha);
		}

		public static Tensor add(Tensor left, Scalar right, Scalar alpha)
		{
			return left.add(right, alpha);
		}

		public static Tensor add_(Tensor left, Tensor right)
		{
			return left.add_(right);
		}

		public static Tensor add_(Tensor left, Scalar right)
		{
			return left.add_(right);
		}

		public static Tensor add_(Tensor left, Tensor right, Scalar alpha)
		{
			return left.add_(right, alpha);
		}

		public static Tensor add_(Tensor left, Scalar right, Scalar alpha)
		{
			return left.add_(right, alpha);
		}

		public static Tensor addcdiv(Tensor input, Tensor tensor1, Tensor tensor2, Scalar value)
		{
			return input.addcdiv(tensor1, tensor2, value);
		}

		public static Tensor addcdiv_(Tensor input, Tensor tensor1, Tensor tensor2, Scalar value)
		{
			return input.addcdiv_(tensor1, tensor2, value);
		}

		public static Tensor addcmul(Tensor input, Tensor tensor1, Tensor tensor2, Scalar value)
		{
			return input.addcmul(tensor1, tensor2, value);
		}

		public static Tensor addcmul_(Tensor input, Tensor tensor1, Tensor tensor2, Scalar value)
		{
			return input.addcmul_(tensor1, tensor2, value);
		}

		public static Tensor angle(Tensor input)
		{
			return input.angle();
		}

		public static Tensor asin(Tensor input)
		{
			return input.asin();
		}

		public static Tensor asin_(Tensor input)
		{
			return input.asin_();
		}

		public static Tensor arcsin(Tensor input)
		{
			return input.arcsin();
		}

		public static Tensor arcsin_(Tensor input)
		{
			return input.arcsin_();
		}

		public static Tensor asinh(Tensor input)
		{
			return input.asinh();
		}

		public static Tensor asinh_(Tensor input)
		{
			return input.asinh_();
		}

		public static Tensor arcsinh(Tensor input)
		{
			return input.arcsinh();
		}

		public static Tensor arcsinh_(Tensor input)
		{
			return input.arcsinh_();
		}

		public static Tensor atan(Tensor input)
		{
			return input.atan();
		}

		public static Tensor atan_(Tensor input)
		{
			return input.atan_();
		}

		public static Tensor arctan(Tensor input)
		{
			return input.arctan();
		}

		public static Tensor arctan_(Tensor input)
		{
			return input.arctan_();
		}

		public static Tensor atanh(Tensor input)
		{
			return input.atanh();
		}

		public static Tensor atanh_(Tensor input)
		{
			return input.atanh_();
		}

		public static Tensor arctanh(Tensor input)
		{
			return input.arctanh();
		}

		public static Tensor arctanh_(Tensor input)
		{
			return input.arctanh_();
		}

		public static Tensor atan2(Tensor input, Tensor other)
		{
			return input.atan2(other);
		}

		public static Tensor atan2_(Tensor input, Tensor other)
		{
			return input.atan2_(other);
		}

		public static Tensor arctan2(Tensor input, Tensor other)
		{
			return input.arctan2(other);
		}

		public static Tensor arctan2_(Tensor input, Tensor other)
		{
			return input.arctan2_(other);
		}

		public static Tensor arctan(Tensor input, Tensor other)
		{
			return input.arctan(other);
		}

		public static Tensor arctan_(Tensor input, Tensor other)
		{
			return input.arctan_(other);
		}

		public static Tensor bitwise_not(Tensor input)
		{
			return input.bitwise_not();
		}

		public static Tensor bitwise_not_(Tensor input)
		{
			return input.bitwise_not_();
		}

		public static Tensor bitwise_and(Tensor left, Tensor right)
		{
			return left.bitwise_and(right);
		}

		public static Tensor bitwise_and_(Tensor left, Tensor right)
		{
			return left.bitwise_and_(right);
		}

		public static Tensor bitwise_or(Tensor left, Tensor right)
		{
			return left.bitwise_or(right);
		}

		public static Tensor bitwise_or_(Tensor left, Tensor right)
		{
			return left.bitwise_or_(right);
		}

		public static Tensor bitwise_xor(Tensor left, Tensor right)
		{
			return left.bitwise_xor(right);
		}

		public static Tensor bitwise_xor_(Tensor left, Tensor right)
		{
			return left.bitwise_xor_(right);
		}

		public static Tensor bitwise_left_shift(Tensor left, Tensor right)
		{
			return left.bitwise_left_shift(right);
		}

		public static Tensor bitwise_left_shift_(Tensor left, Tensor right)
		{
			return left.bitwise_left_shift_(right);
		}

		public static Tensor bitwise_right_shift(Tensor left, Tensor right)
		{
			return left.bitwise_right_shift(right);
		}

		public static Tensor bitwise_right_shift_(Tensor left, Tensor right)
		{
			return left.bitwise_right_shift_(right);
		}

		public static Tensor ceil(Tensor input)
		{
			return input.ceil();
		}

		public static Tensor ceil_(Tensor input)
		{
			return input.ceil_();
		}

		public static Tensor clamp(Tensor input, Scalar? min = null, Scalar? max = null)
		{
			return input.clamp(min, max);
		}

		public static Tensor clamp_(Tensor input, Scalar? min = null, Scalar? max = null)
		{
			return input.clamp_(min, max);
		}

		public static Tensor clamp(Tensor input, Tensor? min = null, Tensor? max = null)
		{
			return input.clamp(min, max);
		}

		public static Tensor clamp_(Tensor input, Tensor? min = null, Tensor? max = null)
		{
			return input.clamp_(min, max);
		}

		public static Tensor clip(Tensor input, Scalar? min = null, Scalar? max = null)
		{
			return input.clip(min, max);
		}

		public static Tensor conj_physical(Tensor input)
		{
			return input.conj_physical();
		}

		public static Tensor conj_physical_(Tensor input)
		{
			return input.conj_physical_();
		}

		public static Tensor copysign(Tensor input, Tensor other)
		{
			return input.copysign(other);
		}

		public static Tensor cos(Tensor input)
		{
			return input.cos();
		}

		public static Tensor cos_(Tensor input)
		{
			return input.cos_();
		}

		public static Tensor cosh(Tensor input)
		{
			return input.cosh();
		}

		public static Tensor cosh_(Tensor input)
		{
			return input.cosh_();
		}

		public static Tensor deg2rad(Tensor input)
		{
			return input.deg2rad();
		}

		public static Tensor div(Tensor left, Tensor right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div(right);
		}

		public static Tensor div(Tensor left, Scalar right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div(right);
		}

		public static Tensor div_(Tensor left, Scalar right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div_(right, rounding_mode);
		}

		public static Tensor div_(Tensor left, Tensor right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div_(right);
		}

		public static Tensor divide(Tensor left, Tensor right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div(right);
		}

		public static Tensor divide(Tensor left, Scalar right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div(right);
		}

		public static Tensor divide_(Tensor left, Tensor right, RoundingMode rounding_mode = RoundingMode.None)
		{
			return left.div_(right);
		}

		public static Tensor divide_(Tensor left, Scalar right)
		{
			return left.div_(right);
		}

		public static Tensor digamma(Tensor input)
		{
			return input.digamma();
		}

		public static Tensor digamma_(Tensor input)
		{
			return input.digamma_();
		}

		public static Tensor erf(Tensor input)
		{
			return input.erf();
		}

		public static Tensor erf_(Tensor input)
		{
			return input.erf_();
		}

		public static Tensor erfc(Tensor input)
		{
			return input.erfc();
		}

		public static Tensor erfc_(Tensor input)
		{
			return input.erfc_();
		}

		public static Tensor erfinv(Tensor input)
		{
			return input.erf();
		}

		public static Tensor erfinv_(Tensor input)
		{
			return input.erfinv_();
		}

		public static Tensor exp(Tensor input)
		{
			return input.exp();
		}

		public static Tensor exp_(Tensor input)
		{
			return input.exp_();
		}

		public static Tensor exp2(Tensor input)
		{
			return input.exp2();
		}

		public static Tensor expm1(Tensor input)
		{
			return input.expm1();
		}

		public static Tensor expm1_(Tensor input)
		{
			return input.expm1_();
		}

		[Obsolete("not implemented", true)]
		public static Tensor fake_quantize_per_channel_affine(Tensor input, Tensor scale, Tensor zero_point, int axis, long quant_min, long quant_max)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static Tensor fake_quantize_per_tensor_affine(Tensor input, Tensor scale, Tensor zero_point, long quant_min, long quant_max)
		{
			throw new NotImplementedException();
		}

		public static Tensor fix(Tensor input)
		{
			return input.fix();
		}

		public static Tensor fix_(Tensor input)
		{
			return input.fix_();
		}

		public static Tensor float_power(Tensor input, Tensor target)
		{
			return input.float_power(target);
		}

		public static Tensor floor(Tensor input)
		{
			return input.floor();
		}

		public static Tensor floor_(Tensor input)
		{
			return input.floor_();
		}

		public static Tensor floor_divide(Tensor input, Tensor other)
		{
			return input.floor_divide(other);
		}

		public static Tensor floor_divide_(Tensor input, Tensor other)
		{
			return input.floor_divide_(other);
		}

		public static Tensor fmod(Tensor left, Tensor right)
		{
			return left.fmod(right);
		}

		public static Tensor fmod_(Tensor left, Tensor right)
		{
			return left.fmod_(right);
		}

		public static Tensor fmod(Tensor left, Scalar right)
		{
			return left.fmod(right);
		}

		public static Tensor fmod_(Tensor left, Scalar right)
		{
			return left.fmod_(right);
		}

		public static Tensor frac(Tensor input)
		{
			return input.frac();
		}

		public static Tensor frac_(Tensor input)
		{
			return input.frac_();
		}

		public static (Tensor Mantissa, Tensor Exponent) frexp(Tensor input)
		{
			return input.frexp();
		}

		[Obsolete("not implemented", true)]
		public static ICollection<Tensor> gradient(Tensor input, int spacing = 1, long? dim = null, int edge_order = 1)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static ICollection<Tensor> gradient(Tensor input, int spacing = 1, long[]? dims = null, int edge_order = 1)
		{
			throw new NotImplementedException();
		}

		public static Tensor imag(Tensor input)
		{
			return input.imag;
		}

		public static Tensor ldexp(Tensor input, Tensor other)
		{
			return input.ldexp(other);
		}

		public static Tensor ldexp_(Tensor input, Tensor other)
		{
			return input.ldexp_(other);
		}

		public static Tensor lerp(Tensor input, Tensor end, Tensor weight)
		{
			return input.lerp(end, weight);
		}

		public static Tensor lgamma(Tensor input)
		{
			return input.lgamma();
		}

		public static Tensor lgamma_(Tensor input)
		{
			return input.lgamma();
		}

		public static Tensor log(Tensor input)
		{
			return input.log();
		}

		public static Tensor log_(Tensor input)
		{
			return input.log_();
		}

		public static Tensor log10(Tensor input)
		{
			return input.log10();
		}

		public static Tensor log10_(Tensor input)
		{
			return input.log10_();
		}

		public static Tensor log1p(Tensor input)
		{
			return input.log1p();
		}

		public static Tensor log1p_(Tensor input)
		{
			return input.log1p_();
		}

		public static Tensor log2(Tensor input)
		{
			return input.log2();
		}

		public static Tensor log2_(Tensor input)
		{
			return input.log2_();
		}

		public static Tensor logaddexp(Tensor left, Tensor right)
		{
			return left.logaddexp(right);
		}

		public static Tensor logaddexp2(Tensor left, Tensor right)
		{
			return left.logaddexp2(right);
		}

		public static Tensor logical_and(Tensor left, Tensor right)
		{
			return left.logical_and(right);
		}

		public static Tensor logical_and_(Tensor left, Tensor right)
		{
			return left.logical_and_(right);
		}

		public static Tensor logical_not(Tensor input)
		{
			return input.logical_not();
		}

		public static Tensor logical_or(Tensor left, Tensor right)
		{
			return left.logical_or(right);
		}

		public static Tensor logical_or_(Tensor left, Tensor right)
		{
			return left.logical_or_(right);
		}

		public static Tensor logical_xor(Tensor left, Tensor right)
		{
			return left.logical_xor(right);
		}

		public static Tensor logical_xor_(Tensor left, Tensor right)
		{
			return left.logical_xor_(right);
		}

		public static Tensor logit(Tensor input, double? eps = null)
		{
			return input.logit(eps);
		}

		public static Tensor hypot(Tensor left, Tensor right)
		{
			return left.hypot(right);
		}

		public static Tensor i0(Tensor input)
		{
			return special.i0(input);
		}

		public static Tensor igamma(Tensor input, Tensor other)
		{
			return special.gammainc(input, other);
		}

		public static Tensor igammac(Tensor input, Tensor other)
		{
			return special.gammaincc(input, other);
		}

		public static Tensor mul(Tensor left, Tensor right)
		{
			return left.mul(right);
		}

		public static Tensor mul(Tensor left, Scalar right)
		{
			return left.mul(right);
		}

		public static Tensor mul_(Tensor left, Tensor right)
		{
			return left.mul_(right);
		}

		public static Tensor mul_(Tensor left, Scalar right)
		{
			return left.mul_(right);
		}

		public static Tensor multiply(Tensor left, Tensor right)
		{
			return left.mul(right);
		}

		public static Tensor multiply(Tensor left, Scalar right)
		{
			return left.mul(right);
		}

		public static Tensor multiply_(Tensor left, Tensor right)
		{
			return left.mul_(right);
		}

		public static Tensor multiply_(Tensor left, Scalar right)
		{
			return left.mul_(right);
		}

		public static Tensor mvlgamma(Tensor input, long p)
		{
			return input.mvlgamma(p);
		}

		public static Tensor mvlgamma_(Tensor input, long p)
		{
			return input.mvlgamma_(p);
		}

		public static Tensor nan_to_num(Tensor input, double nan = 0.0, double? posinf = null, double? neginf = null)
		{
			return input.nan_to_num(nan, posinf, neginf);
		}

		public static Tensor neg(Tensor input)
		{
			return input.neg();
		}

		public static Tensor neg_(Tensor input)
		{
			return input.neg_();
		}

		public static Tensor negative(Tensor input)
		{
			return input.neg();
		}

		public static Tensor negative_(Tensor input)
		{
			return input.neg_();
		}

		public static Tensor nextafter(Tensor input, Tensor other)
		{
			return input.nextafter(other);
		}

		public static Tensor polygamma(Tensor input, long p)
		{
			return input.polygamma(p);
		}

		public static Tensor polygamma_(Tensor input, long p)
		{
			return input.polygamma_(p);
		}

		public static Tensor positive(Tensor input)
		{
			return input.positive();
		}

		public static Tensor pow(Tensor left, Tensor exponent)
		{
			return left.pow(exponent);
		}

		public static Tensor pow(Tensor left, Scalar exponent)
		{
			return left.pow(exponent);
		}

		public static Tensor pow_(Tensor left, Tensor exponent)
		{
			return left.pow_(exponent);
		}

		public static Tensor pow_(Tensor left, Scalar exponent)
		{
			return left.pow_(exponent);
		}

		[Obsolete("not implemented", true)]
		public static Tensor quantized_batch_norm(Tensor input, Tensor? weight, Tensor? bias, Tensor mean, Tensor var, double eps, double output_scale, long output_zero_point)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static Tensor quantized_max_pool1d(Tensor input, long[] kernel_size, long[]? stride, long[]? padding, long dilation = 1L, bool ceil_mode = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static Tensor quantized_max_pool2d(Tensor input, long[] kernel_size, long[]? stride, long[]? padding, long dilation = 1L, bool ceil_mode = false)
		{
			throw new NotImplementedException();
		}

		public static Tensor rad2deg(Tensor input)
		{
			return input.rad2deg();
		}

		public static Tensor real(Tensor input)
		{
			return input.real;
		}

		public static Tensor reciprocal(Tensor input)
		{
			return input.reciprocal();
		}

		public static Tensor reciprocal_(Tensor input)
		{
			return input.reciprocal_();
		}

		public static Tensor remainder(Tensor left, Tensor right)
		{
			return left.remainder(right);
		}

		public static Tensor remainder(Tensor left, Scalar right)
		{
			return left.remainder(right);
		}

		public static Tensor remainder_(Tensor left, Tensor right)
		{
			return left.remainder_(right);
		}

		public static Tensor remainder_(Tensor left, Scalar right)
		{
			return left.remainder_(right);
		}

		public static Tensor round(Tensor input, long decimals = 0L)
		{
			return input.round(decimals);
		}

		public static Tensor round_(Tensor input, long decimals = 0L)
		{
			return input.round_(decimals);
		}

		public static Tensor rsqrt(Tensor input)
		{
			return input.rsqrt();
		}

		public static Tensor rsqrt_(Tensor input)
		{
			return input.rsqrt_();
		}

		public static Tensor sigmoid(Tensor input)
		{
			return input.sigmoid();
		}

		public static Tensor sigmoid_(Tensor input)
		{
			return input.sigmoid_();
		}

		public static Tensor sign(Tensor input)
		{
			return input.sign();
		}

		public static Tensor sign_(Tensor input)
		{
			return input.sign_();
		}

		public static Tensor sgn(Tensor input)
		{
			return input.sgn();
		}

		public static Tensor sgn_(Tensor input)
		{
			return input.sgn_();
		}

		public static Tensor signbit(Tensor input)
		{
			return input.signbit();
		}

		public static Tensor sin(Tensor input)
		{
			return input.sin();
		}

		public static Tensor sin_(Tensor input)
		{
			return input.sin_();
		}

		public static Tensor sinc(Tensor input)
		{
			return input.sinc();
		}

		public static Tensor sinc_(Tensor input)
		{
			return input.sinc_();
		}

		public static Tensor sinh(Tensor input)
		{
			return input.sinh();
		}

		public static Tensor sinh_(Tensor input)
		{
			return input.sinh_();
		}

		public static Tensor sqrt(Tensor input)
		{
			return input.sqrt();
		}

		public static Tensor sqrt_(Tensor input)
		{
			return input.sqrt_();
		}

		public static Tensor square(Tensor input)
		{
			return input.square();
		}

		public static Tensor sub(Tensor left, Tensor right)
		{
			return left.sub(right);
		}

		public static Tensor sub(Tensor left, Scalar right)
		{
			return left.sub(right);
		}

		public static Tensor sub_(Tensor left, Tensor right)
		{
			return left.sub_(right);
		}

		public static Tensor sub_(Tensor left, Scalar right)
		{
			return left.sub_(right);
		}

		public static Tensor subtract(Tensor left, Tensor right)
		{
			return left.subtract(right);
		}

		public static Tensor subtract(Tensor left, Scalar right)
		{
			return left.subtract(right);
		}

		public static Tensor subtract_(Tensor left, Tensor right)
		{
			return left.subtract_(right);
		}

		public static Tensor subtract_(Tensor left, Scalar right)
		{
			return left.subtract_(right);
		}

		public static Tensor tan(Tensor input)
		{
			return input.tan();
		}

		public static Tensor tan_(Tensor input)
		{
			return input.tan_();
		}

		public static Tensor tanh(Tensor input)
		{
			return input.tanh();
		}

		public static Tensor tanh_(Tensor input)
		{
			return input.tanh_();
		}

		public static Tensor true_divide(Tensor dividend, Tensor divisor)
		{
			return dividend.true_divide(divisor);
		}

		public static Tensor true_divide_(Tensor dividend, Tensor divisor)
		{
			return dividend.true_divide_(divisor);
		}

		public static Tensor trunc(Tensor input)
		{
			return input.trunc();
		}

		public static Tensor trunc_(Tensor input)
		{
			return input.trunc_();
		}

		public static Tensor xlogy(Tensor x, Tensor y)
		{
			return x.xlogy(y);
		}

		public static Tensor xlogy_(Tensor x, Tensor y)
		{
			return x.xlogy_(y);
		}

		public static Tensor xlogy(Tensor x, Scalar y)
		{
			return x.xlogy(y);
		}

		public static Tensor xlogy_(Tensor x, Scalar y)
		{
			return x.xlogy_(y);
		}

		public static long seed()
		{
			return random.seed();
		}

		public static Generator manual_seed(long seed)
		{
			return random.manual_seed(seed);
		}

		public static long initial_seed()
		{
			return random.initial_seed();
		}

		public static Tensor get_rng_state()
		{
			return random.get_rng_state();
		}

		public static void set_rng_state(Tensor new_state)
		{
			random.set_rng_state(new_state);
		}

		public static Tensor bernoulli(Tensor input, Generator? generator = null)
		{
			return input.bernoulli(generator);
		}

		public static Tensor multinomial(Tensor input, long num_samples, bool replacement = false, Generator? generator = null)
		{
			return input.multinomial(num_samples, replacement, generator);
		}

		public static Tensor normal(Tensor mean, Tensor std, Generator? generator = null)
		{
			if (std.device_type != mean.device_type || (std.device_type == DeviceType.CUDA && std.device_index != mean.device_index))
			{
				throw new ArgumentException("The 'means' and 'stddev' tensors must be located on the same device.");
			}
			return randn(mean.shape, null, std.device, requires_grad: false, generator) * std + mean;
		}

		public static Tensor poisson(Tensor input, Generator? generator = null)
		{
			return input.poisson(generator);
		}

		private static Tensor rand(long[] size, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false)
		{
			return rand(size, dtype, device, requires_grad);
		}

		private static Tensor rand_like(Tensor input, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false, memory_format memory_format = memory_format.preserve_format)
		{
			return rand_like(input, dtype, device, requires_grad);
		}

		private static Tensor randint(long low, long high, Size size, Generator? generator = null, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false)
		{
			return randint(low, high, size, dtype, device, requires_grad, generator);
		}

		private static Tensor randint(long high, Size size, Generator? generator = null, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false)
		{
			return randint(high, size, dtype, device, requires_grad, generator);
		}

		private static Tensor randint_like(Tensor input, long low, long high, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false, memory_format memory_format = memory_format.preserve_format)
		{
			return randint_like(input, low, high, dtype, device, requires_grad);
		}

		private static Tensor randn(long[] size, Generator? generator = null, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false)
		{
			return randn(size, dtype, device, requires_grad, generator);
		}

		private static Tensor randn_like(Tensor input, ScalarType? dtype = null, layout layout = layout.strided, Device? device = null, bool requires_grad = false, memory_format memory_format = memory_format.preserve_format)
		{
			return input.rand_like(dtype, device, requires_grad);
		}

		public static Tensor rand_like(Tensor input, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			return input.rand_like(dtype, device, requires_grad);
		}

		public static Tensor randperm(long n, ScalarType? dtype = null, Device? device = null, bool requires_grad = false, Generator? generator = null)
		{
			return randperm(n, generator, dtype, layout.strided, device);
		}

		public static Tensor randperm(long n, Tensor @out, Generator? generator = null)
		{
			IntPtr intPtr = NativeMethods.THSTensor_randperm_out(generator?.Handle ?? IntPtr.Zero, n, @out.Handle);
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		private static Tensor randperm(long n, Generator? generator = null, ScalarType? dtype = ScalarType.Int64, layout layout = layout.strided, Device? device = null, bool requires_grad = false, bool pin_memory = false)
		{
			device = InitializeDevice(device);
			ScalarType valueOrDefault = dtype.GetValueOrDefault();
			if (!dtype.HasValue)
			{
				valueOrDefault = ScalarType.Int64;
				dtype = valueOrDefault;
			}
			IntPtr generator2 = generator?.Handle ?? IntPtr.Zero;
			IntPtr intPtr = NativeMethods.THSTensor_randperm(generator2, n, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_randperm(generator2, n, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor argmax(Tensor input)
		{
			return input.argmax();
		}

		public static Tensor argmax(Tensor input, long dim, bool keepdim = false)
		{
			return input.argmax(dim, keepdim);
		}

		public static Tensor argmin(Tensor input)
		{
			return input.argmin();
		}

		public static Tensor argmin(Tensor input, long dim, bool keepdim = false)
		{
			return input.argmin(dim, keepdim);
		}

		public static Tensor amax(Tensor input, long[] dims, bool keepdim = false, Tensor? @out = null)
		{
			return input.amax(dims, keepdim, @out);
		}

		public static Tensor amax(Tensor input, ReadOnlySpan<long> dims, bool keepdim = false, Tensor? @out = null)
		{
			return input.amax(dims, keepdim, @out);
		}

		public static Tensor amax(Tensor input, long[] dims)
		{
			return input.amax(dims);
		}

		public static Tensor amin(Tensor input, long[] dims, bool keepdim = false, Tensor? @out = null)
		{
			return input.amin(dims, keepdim, @out);
		}

		public static Tensor amin(Tensor input, ReadOnlySpan<long> dims, bool keepdim = false, Tensor? @out = null)
		{
			return input.amin(dims, keepdim, @out);
		}

		public static (Tensor min, Tensor max) aminmax(Tensor input, long? dim = null, bool keepdim = false)
		{
			return input.aminmax(dim, keepdim);
		}

		public static Tensor all(Tensor input)
		{
			return input.all();
		}

		public static Tensor all(Tensor input, long dim, bool keepdim = false)
		{
			return input.all(dim, keepdim);
		}

		public static Tensor any(Tensor input)
		{
			return input.any();
		}

		public static Tensor any(Tensor input, long dim, bool keepdim = false)
		{
			return input.any(dim, keepdim);
		}

		public static Tensor max(Tensor input)
		{
			return input.max();
		}

		public static Tensor max(Tensor input, Tensor other)
		{
			return maximum(input, other);
		}

		public static (Tensor values, Tensor indexes) max(Tensor input, long dim, bool keepdim = false)
		{
			return input.max(dim, keepdim);
		}

		public static Tensor min(Tensor input)
		{
			return input.min();
		}

		public static Tensor min(Tensor input, Tensor other)
		{
			return minimum(input, other);
		}

		public static (Tensor values, Tensor indexes) min(Tensor input, long dim, bool keepdim = false)
		{
			return input.min(dim, keepdim);
		}

		public static Tensor dist(Tensor input, Tensor other, float p = 2f)
		{
			return input.dist(other, p);
		}

		public static Tensor logsumexp(Tensor input, long dim, bool keepdim = false)
		{
			return input.logsumexp(dim, keepdim);
		}

		public static Tensor mean(Tensor input)
		{
			return input.mean();
		}

		public static Tensor mean(Tensor input, long[] dimensions, bool keepdim = false, ScalarType? type = null)
		{
			return input.mean(dimensions, keepdim, type);
		}

		public static Tensor nanmean(Tensor input, int? dim = null, bool keepdim = false, ScalarType? dtype = null)
		{
			return input.nanmean(dim, keepdim, dtype);
		}

		public static Tensor median(Tensor input)
		{
			return input.median();
		}

		public static Tensor nanmedian(Tensor input)
		{
			return input.nanmedian();
		}

		public static (Tensor values, Tensor indices) mode(Tensor input, long dim = -1L, bool keepdim = false)
		{
			return input.mode(dim, keepdim);
		}

		public static Tensor norm(Tensor input, float p = 2f)
		{
			return input.norm(p);
		}

		public static Tensor norm(Tensor input, int dimension, bool keepdim = false, float p = 2f)
		{
			return input.norm(dimension, keepdim, p);
		}

		public static Tensor nansum(Tensor input)
		{
			return input.nansum();
		}

		public static Tensor quantile(Tensor input, Tensor q, long dim = -1L, bool keepdim = false)
		{
			return input.quantile(q, dim, keepdim);
		}

		public static Tensor nanquantile(Tensor input, Tensor q, long dim = -1L, bool keepdim = false)
		{
			return input.nanquantile(q, dim, keepdim);
		}

		public static Tensor prod(Tensor input, ScalarType? type = null)
		{
			return input.prod(type);
		}

		public static Tensor prod(Tensor input, long dim, bool keepdim = false, ScalarType? type = null)
		{
			return input.prod(dim, keepdim, type);
		}

		public static Tensor std(Tensor input, bool unbiased = true)
		{
			return input.std(unbiased);
		}

		public static Tensor std(Tensor input, long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std(dimensions, unbiased, keepdim, type);
		}

		public static Tensor std(Tensor input, long dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std(dimensions, unbiased, keepdim, type);
		}

		public static Tensor std(Tensor input, (long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std(dimensions, unbiased, keepdim, type);
		}

		public static Tensor std(Tensor input, (long, long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor std, Tensor mean) std_mean(Tensor input, long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor std, Tensor mean) std_mean(Tensor input, ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor std, Tensor mean) std_mean(Tensor input, long dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor std, Tensor mean) std_mean(Tensor input, (long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor std, Tensor mean) std_mean(Tensor input, (long, long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.std_mean(dimensions, unbiased, keepdim, type);
		}

		public static Tensor sum(Tensor input, ScalarType? type = null)
		{
			return input.sum(type);
		}

		public static Tensor sum(Tensor input, ReadOnlySpan<long> dim, bool keepdim = false, ScalarType? type = null)
		{
			return input.sum(dim, keepdim, type);
		}

		public static Tensor sum(Tensor input, long dim, bool keepdim = false, ScalarType? type = null)
		{
			return input.sum(dim, keepdim, type);
		}

		public static (Tensor output, Tensor? inverse_indices, Tensor? counts) unique(Tensor input, bool sorted = true, bool return_inverse = false, bool return_counts = false, int? dim = null)
		{
			return input.unique(sorted, return_inverse, return_counts, dim);
		}

		public static (Tensor output, Tensor? inverse_indices, Tensor? counts) unique_consecutive(Tensor input, bool return_inverse = false, bool return_counts = false, int? dim = null)
		{
			return input.unique_consecutive(return_inverse, return_counts, dim);
		}

		public static Tensor var(Tensor input, bool unbiased = true)
		{
			return input.var(unbiased);
		}

		public static Tensor var(Tensor input, long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var(dimensions, unbiased, keepdim, type);
		}

		public static Tensor var(Tensor input, long dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var(dimensions, unbiased, keepdim, type);
		}

		public static Tensor var(Tensor input, (long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var(dimensions, unbiased, keepdim, type);
		}

		public static Tensor var(Tensor input, (long, long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor var, Tensor mean) var_mean(Tensor input, bool unbiased = true)
		{
			return input.std_mean(unbiased);
		}

		public static (Tensor var, Tensor mean) var_mean(Tensor input, long[] dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor var, Tensor mean) var_mean(Tensor input, ReadOnlySpan<long> dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor var, Tensor mean) var_mean(Tensor input, long dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor var, Tensor mean) var_mean(Tensor input, (long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var_mean(dimensions, unbiased, keepdim, type);
		}

		public static (Tensor var, Tensor mean) var_mean(Tensor input, (long, long, long) dimensions, bool unbiased = true, bool keepdim = false, ScalarType? type = null)
		{
			return input.var_mean(dimensions, unbiased, keepdim, type);
		}

		public static Tensor count_nonzero(Tensor input, long[]? dims = null)
		{
			return input.count_nonzero(dims);
		}

		public static void save(Tensor t, string location)
		{
			t.save(location);
		}

		public static Tensor load(string location)
		{
			return Tensor.load(location);
		}

		public static Tensor stft(Tensor input, long n_fft, long hop_length = -1L, long win_length = -1L, Tensor? window = null, bool center = true, PaddingModes pad_mode = PaddingModes.Reflect, bool normalized = false, bool? onesided = null, bool? return_complex = null)
		{
			return input.stft(n_fft, hop_length, win_length, window, center, pad_mode, normalized, onesided, return_complex);
		}

		public static Tensor istft(Tensor input, long n_fft, long hop_length = -1L, long win_length = -1L, Tensor? window = null, bool center = true, bool normalized = false, bool? onesided = null, long length = -1L, bool return_complex = false)
		{
			return input.istft(n_fft, hop_length, win_length, window, center, normalized, onesided, length, return_complex);
		}

		public static Tensor bartlett_window(long len, bool periodic = true, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			if (!dtype.Value.IsFloatingPoint())
			{
				throw new ArgumentException("Only floating point types are supported.");
			}
			IntPtr intPtr = NativeMethods.THSTensor_bartlett_window(len, periodic, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_bartlett_window(len, periodic, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor blackman_window(long len, bool periodic = true, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			if (!dtype.Value.IsFloatingPoint())
			{
				throw new ArgumentException("Only floating point types are supported.");
			}
			IntPtr intPtr = NativeMethods.THSTensor_blackman_window(len, periodic, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_blackman_window(len, periodic, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor hamming_window(long len, bool periodic = true, float alpha = 0.54f, float beta = 0.46f, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			if (!dtype.Value.IsFloatingPoint())
			{
				throw new ArgumentException("Only floating point types are supported.");
			}
			IntPtr intPtr = NativeMethods.THSTensor_hamming_window(len, periodic, alpha, beta, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_hamming_window(len, periodic, alpha, beta, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor hann_window(long len, bool periodic = true, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			if (!dtype.Value.IsFloatingPoint())
			{
				throw new ArgumentException("Only floating point types are supported.");
			}
			IntPtr intPtr = NativeMethods.THSTensor_hann_window(len, periodic, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_hann_window(len, periodic, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static Tensor kaiser_window(long len, bool periodic = true, float beta = 12f, ScalarType? dtype = null, Device? device = null, bool requires_grad = false)
		{
			device = InitializeDevice(device);
			if (!dtype.HasValue)
			{
				dtype = get_default_dtype();
			}
			if (!dtype.Value.IsFloatingPoint())
			{
				throw new ArgumentException("Only floating point types are supported.");
			}
			IntPtr intPtr = NativeMethods.THSTensor_kaiser_window(len, periodic, beta, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			if (intPtr == IntPtr.Zero)
			{
				GC.Collect();
				GC.WaitForPendingFinalizers();
				intPtr = NativeMethods.THSTensor_kaiser_window(len, periodic, beta, (sbyte)dtype.Value, (int)device.type, device.index, requires_grad);
			}
			if (intPtr == IntPtr.Zero)
			{
				CheckForErrors();
			}
			return new Tensor(intPtr);
		}

		public static bool is_tensor(object obj)
		{
			return obj is Tensor;
		}

		public static bool is_storage(object obj)
		{
			return obj is Storage;
		}

		public static bool is_complex(Tensor input)
		{
			return is_complex(input.dtype);
		}

		public static bool is_floating_point(Tensor input)
		{
			return is_floating_point(input.dtype);
		}

		public static bool is_nonzero(Tensor input)
		{
			return input.is_nonzero();
		}

		public static void set_default_dtype(ScalarType dtype)
		{
			if (!dtype.IsFloatingPoint())
			{
				throw new ArgumentException("only floating-point types are supported as the default type");
			}
			default_dtype = dtype;
		}

		public static ScalarType get_default_dtype()
		{
			return default_dtype;
		}

		public static Device get_default_device()
		{
			return default_device;
		}

		public static void set_default_tensor_type(Tensor t)
		{
			set_default_dtype(t.dtype);
		}

		public static void set_default_device(Device device)
		{
			if (device == null)
			{
				throw new ArgumentNullException("device");
			}
			default_device = device;
		}

		public static void set_default_device(string device)
		{
			set_default_device(new Device(device));
		}

		public static long numel(Tensor input)
		{
			return input.numel();
		}

		[Obsolete("not implemented", true)]
		public static bool compiled_with_cxx11_abi()
		{
			throw new NotImplementedException();
		}

		public static ScalarType result_type(Tensor tensor1, Tensor tensor2)
		{
			int num = NativeMethods.THSTensor_result_type(tensor1.Handle, tensor2.Handle);
			if (num == -1)
			{
				CheckForErrors();
			}
			return (ScalarType)num;
		}

		public static bool can_cast(ScalarType from, ScalarType to)
		{
			int num = NativeMethods.THSTorch_can_cast((int)from, (int)to);
			if (num == -1)
			{
				CheckForErrors();
			}
			return num != 0;
		}

		public static ScalarType promote_types(ScalarType type1, ScalarType type2)
		{
			int num = NativeMethods.THSTorch_promote_types((int)type1, (int)type2);
			if (num == -1)
			{
				CheckForErrors();
			}
			return (ScalarType)num;
		}

		[Obsolete("not implemented", true)]
		public static IDisposable use_deterministic_algorithms(bool mode = true, bool warn_only = false)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static bool are_deterministic_algorithms_enabled()
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static bool is_deterministic_algorithms_warn_only_enabled()
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static IDisposable set_deterministic_debug_mode(DebugMode mode)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static DebugMode get_deterministic_debug_mode()
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static IDisposable set_float32_matmul_precision(Float32MatmulPrecision precision)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static Float32MatmulPrecision get_float32_matmul_precision()
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static IDisposable set_warn_always(bool mode = true)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static bool is_warn_always_enabled()
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static void _assert(bool condition, string message)
		{
			throw new NotImplementedException();
		}

		[Obsolete("not implemented", true)]
		public static void _assert(Func<bool> condition, string message)
		{
			throw new NotImplementedException();
		}

		public static string NormalizeNuGetVersion(string versionString)
		{
			if (string.IsNullOrWhiteSpace(versionString))
			{
				throw new ArgumentException("Invalid NuGet version: " + versionString + ". Version string is null, empty or only contains whitespaces");
			}
			string[] array = versionString.Split('-', '+');
			string[] array2 = array[0].Split(new char[1] { '.' });
			if (array2.Length < 2 || array2.Length > 4 || !array2.All((string v) => int.TryParse(v, out var _)))
			{
				throw new ArgumentException("Invalid NuGet version: " + versionString + ". Please check: https://learn.microsoft.com/en-us/nuget/concepts/package-versioning");
			}
			string text = array2[0] + "." + array2[1];
			if (array2.Length > 2)
			{
				text = text + "." + array2[2];
			}
			if (array2.Length > 3 && int.Parse(array2[3]) != 0)
			{
				text = text + "." + array2[3];
			}
			if (array.Length > 1)
			{
				text = text + "-" + array[1];
			}
			return text;
		}

		internal static bool TryLoadNativeLibraryFromFile(string path, StringBuilder trace)
		{
			bool flag;
			try
			{
				trace.AppendLine("    Trying to load native component " + path);
				flag = System.NativeLibrary.TryLoad(path, out var _);
				if (!flag)
				{
					trace.AppendLine("    Failed to load native component " + path);
				}
			}
			catch (Exception ex)
			{
				trace.AppendLine("    Failed to load native component " + path + ": " + ex.Message);
				flag = false;
			}
			return flag;
		}

		internal static bool TryLoadNativeLibraryByName(string name, Assembly assembly, StringBuilder trace)
		{
			bool flag;
			try
			{
				trace.AppendLine("    Trying to load native component " + name + " relative to " + assembly.Location);
				flag = System.NativeLibrary.TryLoad(name, assembly, null, out var _);
				if (!flag)
				{
					trace.AppendLine("    Failed to load native component " + name + " relative to " + assembly.Location);
				}
			}
			catch (Exception ex)
			{
				trace.AppendLine("    Failed to load native component " + name + " relative to " + assembly.Location + ": " + ex.Message);
				flag = false;
			}
			return flag;
		}

		private static void LoadNativeBackend(bool useCudaBackend, out StringBuilder? trace)
		{
			if (!Environment.Is64BitProcess)
			{
				throw new NotSupportedException("TorchSharp only supports 64-bit processes.");
			}
			bool num = (useCudaBackend ? nativeBackendCudaLoaded : nativeBackendLoaded);
			trace = null;
			if (num)
			{
				return;
			}
			trace = new StringBuilder();
			trace.AppendLine("");
			trace.AppendLine($"TorchSharp: LoadNativeBackend: Initialising native backend, useCudaBackend = {useCudaBackend}");
			trace.AppendLine("");
			trace.AppendLine("Step 1 - First try regular load of native libtorch binaries.");
			trace.AppendLine("");
			bool flag;
			if (useCudaBackend)
			{
				if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
				{
					trace.AppendLine("    Try loading Windows cuda native components");
					flag = TryLoadNativeLibraryByName("cudnn_adv64_9", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cudnn_cnn64_9", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cudnn_ops64_9", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cudnn_graph64_9.dll", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cudnn_heuristic64_9.dll", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cudnn_engines_precompiled64_9.dll", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cudnn_engines_runtime_compiled64_9.dll", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("nvrtc-builtins64_128", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("caffe2_nvrtc", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("nvrtc64_120_0", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cublasLt64_12", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cufft64_11", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cusparse64_12", typeof(torch).Assembly, trace);
					flag = TryLoadNativeLibraryByName("cusolver64_11", typeof(torch).Assembly, trace);
				}
				flag = TryLoadNativeLibraryByName("torch_cuda", typeof(torch).Assembly, trace);
				flag = TryLoadNativeLibraryByName("LibTorchSharp", typeof(torch).Assembly, trace);
			}
			else
			{
				flag = TryLoadNativeLibraryByName("torch_cpu", typeof(torch).Assembly, trace);
				flag = TryLoadNativeLibraryByName("LibTorchSharp", typeof(torch).Assembly, trace);
			}
			trace.AppendLine($"    Result from regular native load of LibTorchSharp is {flag}");
			if (!flag)
			{
				trace.AppendLine("");
				trace.AppendLine("Step 3 - Alternative load from consolidated directory of native binaries from nuget packages");
				trace.AppendLine("");
				string text = "libtorch-cpu-" + nativeRid;
				string text2 = "libtorch-cuda-12.8-" + nativeRid;
				string text3 = (RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "LibTorchSharp.dll" : (RuntimeInformation.IsOSPlatform(OSPlatform.OSX) ? "libLibTorchSharp.dylib" : "libLibTorchSharp.so"));
				string directoryName = Path.GetDirectoryName(typeof(torch).Assembly.Location);
				string fullPath = Path.GetFullPath(Path.Combine(directoryName, "..", "..", "..", ".."));
				string fullPath2 = Path.GetFullPath(Path.Combine(directoryName, "..", ".."));
				trace.AppendLine("    torchsharpLoc = " + directoryName);
				trace.AppendLine("    packagesDir = " + fullPath);
				trace.AppendLine("    torchsharpHome = " + fullPath2);
				if (directoryName.Contains("torchsharp") && directoryName.Contains("lib") && Directory.Exists(fullPath) && Directory.Exists(fullPath2))
				{
					string packageVersion = NormalizeNuGetVersion(Path.GetFileName(fullPath2));
					string packageVersion2 = NormalizeNuGetVersion("2.10.0.0");
					if (useCudaBackend)
					{
						string text4 = Path.Combine(directoryName, "cuda-12.8");
						trace.AppendLine("    Trying dynamic load for .NET/F# Interactive by consolidating native " + text2 + "-* binaries to " + text4 + "...");
						bool flag2 = CopyNativeComponentsIntoSingleDirectory(fullPath, text2 + "-*", packageVersion2, text4, trace);
						if (flag2)
						{
							flag2 = CopyNativeComponentsIntoSingleDirectory(fullPath, "torchsharp", packageVersion, text4, trace);
							if (flag2)
							{
								flag = TryLoadNativeLibraryFromFile(Path.Combine(text4, text3), trace);
							}
						}
						if (!flag2)
						{
							string text5 = string.Format("The {0} package version {1} is not restored on this system. If using F# Interactive or .NET Interactive you may need to add a reference to this package, e.g. \n    #r \"nuget: {2}, {3}\". Trace from LoadNativeBackend:\n{4}", text2, "2.10.0.0", text2, "2.10.0.0", trace);
							Console.WriteLine(text5);
							throw new NotSupportedException(text5);
						}
					}
					else
					{
						string text6 = Path.Combine(directoryName, "cpu");
						trace.AppendLine("    Trying dynamic load for .NET/F# Interactive by consolidating native " + text + "-* binaries to " + text6 + "...");
						bool flag3 = CopyNativeComponentsIntoSingleDirectory(fullPath, text, packageVersion2, text6, trace);
						if (flag3)
						{
							flag3 = CopyNativeComponentsIntoSingleDirectory(fullPath, "torchsharp", packageVersion, text6, trace);
							if (flag3)
							{
								flag = TryLoadNativeLibraryFromFile(Path.Combine(text6, text3), trace);
							}
						}
						if (!flag3)
						{
							string text7 = string.Format("The {0} package version {1} is not restored on this system. If using F# Interactive or .NET Interactive you may need to add a reference to this package, e.g. \n    #r \"nuget: {2}, {3}\". Trace from LoadNativeBackend:\n{4}", text, "2.10.0.0", text, "2.10.0.0", trace);
							Console.WriteLine(text7);
							throw new NotSupportedException(text7);
						}
					}
				}
				else
				{
					trace.AppendLine("    Giving up, TorchSharp.dll does not appear to have been loaded from package directories");
				}
				if (!flag)
				{
					string text8 = string.Format("This application or script uses TorchSharp but doesn't contain a reference to {0}, Version={1}.\n\nConsider referencing one of the combination packages TorchSharp-cpu, TorchSharp-cuda-linux, TorchSharp-cuda-windows or call System.Runtime.InteropServices.NativeLibrary.Load(path-to-{2}) explicitly for a Python install of pytorch. See https://github.com/dotnet/TorchSharp/issues/169.\".\n\nFor CUDA, you may need to call 'TorchSharp.torch.InitializeDeviceType(TorchSharp.DeviceType.CUDA)' before any use of TorchSharp CUDA packages from scripts or notebooks.\n\nTrace from LoadNativeBackend:\n{3}", useCudaBackend ? text2 : text, "2.10.0.0", text3, trace);
					Console.WriteLine(text8);
					throw new NotSupportedException(text8);
				}
			}
			if (useCudaBackend)
			{
				nativeBackendCudaLoaded = true;
			}
			else
			{
				nativeBackendLoaded = true;
			}
		}

		private static bool CopyNativeComponentsIntoSingleDirectory(string packagesDir, string packagePattern, string packageVersion, string target, StringBuilder trace)
		{
			trace.AppendLine("    Consolidating native binaries, packagesDir=" + packagesDir + ", packagePattern=" + packagePattern + ", packageVersion=" + packageVersion + " to target=" + target + "...");
			if (Directory.Exists(packagesDir))
			{
				string[] array = (from d in Directory.GetDirectories(packagesDir, packagePattern)
					where Directory.Exists(Path.Combine(d, packageVersion))
					select d).ToArray();
				if (array.Length != 0)
				{
					if (!Directory.Exists(target))
					{
						Directory.CreateDirectory(target);
					}
					string[] array2 = array;
					foreach (string text in array2)
					{
						string text2 = Path.Combine(text, packageVersion, "runtimes", nativeRid, "native");
						trace.AppendLine("    CopyNativeComponentsIntoSingleDirectory: natives=" + text2);
						if (!Directory.Exists(text2))
						{
							continue;
						}
						Regex nativeRegExp = new Regex("^" + nativeGlob + "$");
						foreach (string item in from path in Directory.GetFiles(text2)
							where nativeRegExp.IsMatch(path)
							select path)
						{
							string text3 = Path.Combine(target, Path.GetFileName(item));
							if (!File.Exists(text3))
							{
								trace.AppendLine("Copy " + item + " --> " + text3);
								File.Copy(item, text3);
							}
						}
					}
					return true;
				}
			}
			return false;
		}

		public static bool TryInitializeDeviceType(DeviceType deviceType)
		{
			if (deviceType == DeviceType.MPS && !isAppleSilicon)
			{
				return false;
			}
			LoadNativeBackend(deviceType == DeviceType.CUDA, out StringBuilder _);
			if (deviceType == DeviceType.CUDA)
			{
				return cuda.CallTorchCudaIsAvailable();
			}
			return true;
		}

		public static void InitializeDeviceType(DeviceType deviceType)
		{
			if (deviceType == DeviceType.MPS && !isAppleSilicon)
			{
				throw new InvalidOperationException("Torch device type 'MPS' is not available on this platform.");
			}
			LoadNativeBackend(deviceType == DeviceType.CUDA, out StringBuilder stringBuilder);
			if (deviceType == DeviceType.CUDA && !cuda.CallTorchCudaIsAvailable())
			{
				throw new InvalidOperationException($"Torch device type {deviceType} did not initialise on the current machine. Trace from LoadNativeBackend:\n{stringBuilder?.ToString() ?? string.Empty}");
			}
		}

		public static Device InitializeDevice(Device? device)
		{
			if (device == null)
			{
				device = get_default_device();
			}
			InitializeDeviceType(device.type);
			return device;
		}

		public static bool cuda_is_available()
		{
			return cuda.is_available();
		}

		public static bool mps_is_available()
		{
			return isAppleSilicon;
		}

		public static void CheckForErrors()
		{
			IntPtr intPtr = NativeMethods.THSTorch_get_and_reset_last_err();
			if (intPtr != IntPtr.Zero)
			{
				throw new ExternalException(Marshal.PtrToStringAnsi(intPtr));
			}
		}
	}
	internal static class Extensions
	{
		public static NativeMethods.ArrayWithSize CreateArrayWithSize(this PinnedArray<IntPtr> arr, IntPtr[] array)
		{
			return new NativeMethods.ArrayWithSize
			{
				Array = arr.CreateArray(array),
				Size = array.LongLength
			};
		}
	}
	internal class ConsoleProgressBar : IProgressBar, IDisposable
	{
		private const long DisplayEveryMilliseconds = 100L;

		private readonly int _displayWidth;

		private readonly Stopwatch _stopWatch;

		private bool _hidden;

		private long _value;

		private long? _maximum;

		public long Value
		{
			get
			{
				return _value;
			}
			set
			{
				if (value > _maximum)
				{
					value = _maximum.Value;
				}
				_value = value;
				Display();
			}
		}

		public long? Maximum
		{
			get
			{
				return _maximum;
			}
			set
			{
				if (value < _value)
				{
					_value = value.Value;
				}
				_maximum = value;
				Display();
			}
		}

		internal ConsoleProgressBar(bool hidden)
		{
			_hidden = hidden;
			try
			{
				_displayWidth = Console.BufferWidth;
			}
			catch
			{
				_displayWidth = 80;
			}
			_stopWatch = new Stopwatch();
			_stopWatch.Start();
		}

		public void Dispose()
		{
			if (!_hidden)
			{
				Console.Error.WriteLine();
			}
		}

		private void Display()
		{
			if (_hidden || (_value != 0L && _value != _maximum && _stopWatch.ElapsedMilliseconds <= 100))
			{
				return;
			}
			_stopWatch.Restart();
			if (!Maximum.HasValue)
			{
				Console.Error.Write("\r{0}", _value);
				return;
			}
			string text = $"{100 * _value / _maximum,3}%[";
			string text2 = $"] {_value}/{_maximum}";
			int num = _displayWidth - text.Length - text2.Length - 1;
			string text3 = string.Empty;
			if (num > 0)
			{
				int num2 = (int)(num * _value / _maximum).Value;
				if (num2 > 0)
				{
					text3 = new string('=', num2);
					if (_displayWidth - num2 > 0)
					{
						text3 += new string(' ', num - num2);
					}
				}
				else
				{
					text3 = new string(' ', num);
				}
			}
			Console.Error.Write("\r{0}{1}{2}", text, text3, text2);
		}
	}
	public sealed class DisposeScope : IDisposable
	{
		private DisposeScopeManager? _disposeScopeManager;

		internal DisposeScope? OuterScope { get; set; }

		internal HashSet<IDisposable> Disposables { get; private set; } = new HashSet<IDisposable>(ReferenceEqualityComparer<IDisposable>.Default);

		public IReadOnlyList<IDisposable> DisposablesView
		{
			get
			{
				if (_disposeScopeManager == null)
				{
					throw new ObjectDisposedException(GetType().FullName);
				}
				return Disposables.ToArray();
			}
		}

		public int DisposablesCount
		{
			get
			{
				if (_disposeScopeManager == null)
				{
					throw new ObjectDisposedException(GetType().FullName);
				}
				return Disposables.Count;
			}
		}

		internal DisposeScope(DisposeScopeManager disposeScopeManager)
		{
			_disposeScopeManager = disposeScopeManager;
			OuterScope = disposeScopeManager.CurrentDisposeScope;
		}

		public T MoveToOuter<T>(T disposable) where T : IDisposable
		{
			MoveToOuter(new IDisposable[1] { disposable });
			return disposable;
		}

		public (T1 first, T2 second) MoveToOuter<T1, T2>(T1 first, T2 second) where T1 : IDisposable where T2 : IDisposable
		{
			MoveToOuter(new IDisposable[2] { first, second });
			return (first: first, second: second);
		}

		public (T1 first, T2 second, T3 third) MoveToOuter<T1, T2, T3>(T1 first, T2 second, T3 third) where T1 : IDisposable where T2 : IDisposable where T3 : IDisposable
		{
			MoveToOuter(new IDisposable[3] { first, second, third });
			return (first: first, second: second, third: third);
		}

		public void MoveToOuter(params IDisposable[] disposables)
		{
			MoveToOuter((IEnumerable<IDisposable>)disposables);
		}

		public void MoveToOuter(IEnumerable<IDisposable> disposables)
		{
			MoveToOther(OuterScope, disposables);
		}

		public T MoveToOther<T>(DisposeScope? scope, T disposable) where T : IDisposable
		{
			MoveToOther(scope, new IDisposable[1] { disposable });
			return disposable;
		}

		public (T1 first, T2 second) MoveToOther<T1, T2>(DisposeScope? scope, T1 first, T2 second) where T1 : IDisposable where T2 : IDisposable
		{
			MoveToOther(scope, new IDisposable[2] { first, second });
			return (first: first, second: second);
		}

		public (T1 first, T2 second, T3 third) MoveToOther<T1, T2, T3>(DisposeScope? scope, T1 first, T2 second, T3 third) where T1 : IDisposable where T2 : IDisposable where T3 : IDisposable
		{
			MoveToOther(scope, new IDisposable[3] { first, second, third });
			return (first: first, second: second, third: third);
		}

		public void MoveToOther(DisposeScope? scope, params IDisposable[] disposables)
		{
			MoveToOther(scope, (IEnumerable<IDisposable>)disposables);
		}

		public void MoveToOther(DisposeScope? scope, IEnumerable<IDisposable> disposables)
		{
			if (_disposeScopeManager == null)
			{
				throw new ObjectDisposedException(GetType().FullName);
			}
			if (scope == null)
			{
				Detach(disposables);
				return;
			}
			foreach (IDisposable disposable in disposables)
			{
				if (Disposables.Remove(disposable))
				{
					AddToOther(scope, disposable);
				}
			}
		}

		public T Detach<T>(T disposable) where T : IDisposable
		{
			Detach(new IDisposable[1] { disposable });
			return disposable;
		}

		public (T1 first, T2 second) Detach<T1, T2>(T1 first, T2 second) where T1 : IDisposable where T2 : IDisposable
		{
			Detach(new IDisposable[2] { first, second });
			return (first: first, second: second);
		}

		public (T1 first, T2 second, T3 third) Detach<T1, T2, T3>(T1 first, T2 second, T3 third) where T1 : IDisposable where T2 : IDisposable where T3 : IDisposable
		{
			Detach(new IDisposable[3] { first, second, third });
			return (first: first, second: second, third: third);
		}

		public void Detach(params IDisposable[] disposables)
		{
			Detach((IEnumerable<IDisposable>)disposables);
		}

		public void Detach(IEnumerable<IDisposable> disposables)
		{
			if (_disposeScopeManager == null)
			{
				throw new ObjectDisposedException(GetType().FullName);
			}
			foreach (IDisposable disposable in disposables)
			{
				if (Disposables.Remove(disposable))
				{
					if (disposable is torch.Tensor tensor)
					{
						_disposeScopeManager.StatisticsInstance.TensorStatistics.DetachedFromScopeCount++;
						tensor.OwningDisposeScope = null;
					}
					else if (disposable is torch.nn.utils.rnn.PackedSequence packedSequence)
					{
						_disposeScopeManager.StatisticsInstance.PackedSequenceStatistics.DetachedFromScopeCount++;
						packedSequence.OwningDisposeScope = null;
					}
				}
			}
		}

		internal static void ReplaceWith(torch.Tensor original, torch.Tensor replacement)
		{
			DisposeScope owningDisposeScope = original.OwningDisposeScope;
			if (owningDisposeScope != null && owningDisposeScope.Disposables.Remove(original))
			{
				original.OwningDisposeScope = null;
				AddToOther(owningDisposeScope, replacement);
			}
		}

		public void Attach(IDisposable disposable)
		{
			Attach((IEnumerable<IDisposable>)new IDisposable[1] { disposable });
		}

		public void Attach(params IDisposable[] disposables)
		{
			Attach((IEnumerable<IDisposable>)disposables);
		}

		public IReadOnlyList<IDisposable> Attach(IEnumerable<IDisposable> disposables)
		{
			if (_disposeScopeManager == null)
			{
				throw new ObjectDisposedException(GetType().FullName);
			}
			List<IDisposable> list = new List<IDisposable>();
			foreach (IDisposable disposable in disposables)
			{
				if (AddToOther(this, disposable))
				{
					if (disposable is torch.Tensor)
					{
						_disposeScopeManager.StatisticsInstance.TensorStatistics.AttachedToScopeCount++;
					}
					else if (disposable is torch.nn.utils.rnn.PackedSequence)
					{
						_disposeScopeManager.StatisticsInstance.PackedSequenceStatistics.AttachedToScopeCount++;
					}
				}
				list.Add(disposable);
			}
			return list;
		}

		public void DisposeEverything()
		{
			DisposeEverythingBut(Enumerable.Empty<IDisposable>());
		}

		public void DisposeEverythingBut(IEnumerable<IDisposable> inKeep)
		{
			if (_disposeScopeManager == null)
			{
				throw new ObjectDisposedException(GetType().FullName);
			}
			HashSet<IDisposable> disposables = Disposables;
			Disposables = NSExtension.ToHashSet<IDisposable>(inKeep, ReferenceEqualityComparer<IDisposable>.Default);
			foreach (IDisposable item in disposables)
			{
				if (!Disposables.Contains(item))
				{
					item.Dispose();
				}
			}
		}

		public void DisposeEverythingBut(params IDisposable[] keep)
		{
			DisposeEverythingBut((IEnumerable<IDisposable>)keep);
		}

		public T DisposeEverythingBut<T>(T keep) where T : IDisposable
		{
			DisposeEverythingBut(new IDisposable[1] { keep });
			return keep;
		}

		public (T1 first, T2 second) DisposeEverythingBut<T1, T2>(T1 first, T2 second) where T1 : IDisposable where T2 : IDisposable
		{
			DisposeEverythingBut(new IDisposable[2] { first, second });
			return (first: first, second: second);
		}

		public (T1 first, T2 second, T3 third) DisposeEverythingBut<T1, T2, T3>(T1 first, T2 second, T3 third) where T1 : IDisposable where T2 : IDisposable where T3 : IDisposable
		{
			DisposeEverythingBut(new IDisposable[3] { first, second, third });
			return (first: first, second: second, third: third);
		}

		public void Dispose()
		{
			if (_disposeScopeManager != null)
			{
				DisposeEverything();
				_disposeScopeManager.RemoveDisposeScope(this);
				_disposeScopeManager = null;
			}
		}

		public void MarkAsDisposed(IDisposable disposable)
		{
			if (_disposeScopeManager == null)
			{
				throw new ObjectDisposedException(GetType().FullName);
			}
			Disposables.Remove(disposable);
			if (disposable is torch.Tensor tensor)
			{
				tensor.OwningDisposeScope = null;
			}
			else if (disposable is torch.nn.utils.rnn.PackedSequence packedSequence)
			{
				packedSequence.OwningDisposeScope = null;
			}
		}

		public bool Contains(IDisposable disposable)
		{
			return Disposables.Contains(disposable);
		}

		private static bool AddToOther(DisposeScope scope, IDisposable disposable)
		{
			DisposeScope owningDisposeScope;
			if (disposable is torch.Tensor tensor)
			{
				owningDisposeScope = tensor.OwningDisposeScope;
			}
			else
			{
				if (!(disposable is torch.nn.utils.rnn.PackedSequence packedSequence))
				{
					throw new InvalidOperationException("DisposeScope can only manage Tensor or PackedSequence");
				}
				owningDisposeScope = packedSequence.OwningDisposeScope;
			}
			if (scope == owningDisposeScope)
			{
				return false;
			}
			scope.Disposables.Add(disposable);
			owningDisposeScope?.Disposables.Remove(disposable);
			if (disposable is torch.Tensor tensor2)
			{
				tensor2.OwningDisposeScope = scope;
			}
			else if (disposable is torch.nn.utils.rnn.PackedSequence packedSequence2)
			{
				packedSequence2.OwningDisposeScope = scope;
			}
			return true;
		}

		internal HashSet<IDisposable> DetachAllAndDispose()
		{
			HashSet<IDisposable> disposables = Disposables;
			foreach (IDisposable disposable in Disposables)
			{
				if (disposable is torch.Tensor tensor)
				{
					_disposeScopeManager.StatisticsInstance.TensorStatistics.DetachedFromScopeCount++;
					tensor.OwningDisposeScope = null;
				}
				else if (disposable is torch.nn.utils.rnn.PackedSequence packedSequence)
				{
					_disposeScopeManager.StatisticsInstance.PackedSequenceStatistics.DetachedFromScopeCount++;
					packedSequence.OwningDisposeScope = null;
				}
			}
			Disposables = new HashSet<IDisposable>();
			Dispose();
			return disposables;
		}
	}
	public class DisposeScopeManager
	{
		[ThreadStatic]
		private static DisposeScopeManager? _threadSingleton;

		internal static DisposeScopeManager ThreadSingleton => _threadSingleton ?? (_threadSingleton = new DisposeScopeManager());

		internal ThreadDisposeScopeStatistics StatisticsInstance { get; } = new ThreadDisposeScopeStatistics();

		internal DisposeScope? CurrentDisposeScope { get; private set; }

		public static ThreadDisposeScopeStatistics Statistics => ThreadSingleton.StatisticsInstance;

		internal DisposeScope? RegisterOnCurrentDisposeScope(IDisposable item)
		{
			if (CurrentDisposeScope == null)
			{
				if (item is torch.Tensor)
				{
					StatisticsInstance.TensorStatistics.CreatedOutsideScopeCount++;
				}
				else if (item is torch.nn.utils.rnn.PackedSequence)
				{
					StatisticsInstance.PackedSequenceStatistics.CreatedOutsideScopeCount++;
				}
				return null;
			}
			if (item is torch.Tensor)
			{
				StatisticsInstance.TensorStatistics.CreatedInScopeCount++;
			}
			else if (item is torch.nn.utils.rnn.PackedSequence)
			{
				StatisticsInstance.PackedSequenceStatistics.CreatedInScopeCount++;
			}
			CurrentDisposeScope.Disposables.Add(item);
			return CurrentDisposeScope;
		}

		internal void DisposingOnCurrentScope(torch.Tensor item)
		{
			if (item.OwningDisposeScope == null)
			{
				StatisticsInstance.TensorStatistics.DisposedOutsideScopeCount++;
			}
			else
			{
				StatisticsInstance.TensorStatistics.DisposedInScopeCount++;
			}
		}

		internal void DisposingOnCurrentScope(torch.nn.utils.rnn.PackedSequence item)
		{
			if (item.OwningDisposeScope == null)
			{
				StatisticsInstance.PackedSequenceStatistics.DisposedOutsideScopeCount++;
			}
			else
			{
				StatisticsInstance.PackedSequenceStatistics.DisposedInScopeCount++;
			}
		}

		internal void RemoveDisposeScope(DisposeScope disposeScope)
		{
			DisposeScope disposeScope2 = CurrentDisposeScope;
			if (disposeScope2 == disposeScope)
			{
				CurrentDisposeScope = disposeScope2.OuterScope;
			}
			else
			{
				if (disposeScope2 == null)
				{
					return;
				}
				while (true)
				{
					DisposeScope outerScope = disposeScope2.OuterScope;
					if (outerScope == disposeScope)
					{
						disposeScope2.OuterScope = outerScope.OuterScope;
						break;
					}
					if (outerScope == null)
					{
						break;
					}
					disposeScope2 = outerScope;
				}
			}
		}

		internal DisposeScope NewDisposeScope()
		{
			CurrentDisposeScope = new DisposeScope(this);
			return CurrentDisposeScope;
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public delegate IntPtr DistanceFunctionNative(IntPtr x, IntPtr y);
	public enum FFTNormType
	{
		Backward,
		Forward,
		Ortho
	}
	public interface IProgressBar : IDisposable
	{
		long Value { get; set; }

		long? Maximum { get; set; }
	}
	public enum PaddingModes
	{
		Zeros,
		Reflect,
		Replicate,
		Circular,
		Constant
	}
	public enum Padding
	{
		Valid,
		Same
	}
	public enum EmbeddingBagMode
	{
		Sum,
		Mean,
		Max
	}
	public abstract class Loss<T1, T2, TResult> : torch.nn.Module<T1, T2, TResult>
	{
		public torch.nn.Reduction reduction { get; }

		public Loss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base("Loss")
		{
			this.reduction = reduction;
		}
	}
	public abstract class Loss<T1, T2, T3, TResult> : torch.nn.Module<T1, T2, T3, TResult>
	{
		public torch.nn.Reduction reduction { get; }

		public Loss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base("Loss")
		{
			this.reduction = reduction;
		}
	}
	public abstract class Loss<T1, T2, T3, T4, TResult> : torch.nn.Module<T1, T2, T3, T4, TResult>
	{
		public torch.nn.Reduction reduction { get; }

		public Loss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base("Loss")
		{
			this.reduction = reduction;
		}
	}
	public abstract class WeightedLoss<T1, T2, TResult> : Loss<T1, T2, TResult>
	{
		public torch.Tensor? weight { get; }

		public WeightedLoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.weight = weight;
		}
	}
	public abstract class WeightedLoss<T1, T2, T3, TResult> : Loss<T1, T2, T3, TResult>
	{
		public torch.Tensor? weight { get; }

		public WeightedLoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.weight = weight;
		}
	}
	public abstract class WeightedLoss<T1, T2, T3, T4, TResult> : Loss<T1, T2, T3, T4, TResult>
	{
		public torch.Tensor? weight { get; }

		public WeightedLoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.weight = weight;
		}
	}
	public static class ModuleExtensionMethods
	{
		public static T to<T>(this T module, torch.ScalarType type, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(type, non_blocking);
		}

		public static T to<T>(this T module, torch.Device device, torch.ScalarType type, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(device, type, non_blocking);
		}

		public static T to<T>(this T module, DeviceType deviceType, int deviceIndex = -1, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(deviceType, deviceIndex, non_blocking);
		}

		public static T to<T>(this T module, torch.Device device, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(device.type, device.index, non_blocking);
		}

		public static T to<T>(this T module, string device, bool non_blocking = false) where T : torch.nn.Module
		{
			torch.Device device2 = new torch.Device(device);
			return (T)module._to(device2.type, device2.index, non_blocking);
		}

		public static T to<T>(this T module, torch.Tensor other, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(other.device, other.dtype, non_blocking);
		}

		public static T cpu<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(DeviceType.CPU, -1, non_blocking);
		}

		public static T cuda<T>(this T module, int deviceIndex = -1, bool non_blocking = false) where T : torch.nn.Module
		{
			return (T)module._to(DeviceType.CUDA, deviceIndex, non_blocking);
		}

		public static T @bool<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Bool);
		}

		public static T @byte<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Byte, non_blocking);
		}

		public static T @char<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Int8, non_blocking);
		}

		public static T @short<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Int16, non_blocking);
		}

		public static T @int<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Int32, non_blocking);
		}

		public static T @long<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Int64, non_blocking);
		}

		public static T half<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Float16, non_blocking);
		}

		public static T bfloat16<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.BFloat16, non_blocking);
		}

		public static T @float<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Float32, non_blocking);
		}

		public static T @double<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.Float64, non_blocking);
		}

		public static T cfloat<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.ComplexFloat32, non_blocking);
		}

		public static T cdouble<T>(this T module, bool non_blocking = false) where T : torch.nn.Module
		{
			return module.to(torch.ScalarType.ComplexFloat64, non_blocking);
		}
	}
	public static class FieldInfoExtensionMethods
	{
		public static string ComponentName(this FieldInfo field)
		{
			return field.GetCustomAttribute<ComponentNameAttribute>()?.Name ?? field.Name;
		}
	}
	internal delegate IntPtr ForwardFunctionC(IntPtr tensor);
	public sealed class Scalar : IDisposable
	{
		private IntPtr handle;

		internal IntPtr Handle
		{
			get
			{
				if (handle == IntPtr.Zero)
				{
					throw new InvalidOperationException("Scalar invalid -- empty handle.");
				}
				return handle;
			}
			private set
			{
				handle = value;
			}
		}

		public torch.ScalarType Type => (torch.ScalarType)NativeMethods.THSTorch_scalar_type(Handle);

		internal Scalar(IntPtr handle)
		{
			Handle = handle;
		}

		public static implicit operator Scalar(byte value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(sbyte value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(short value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(int value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(long value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(float value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(double value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(bool value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar((float, float) value)
		{
			return value.ToScalar();
		}

		public static implicit operator Scalar(Complex value)
		{
			return value.ToScalar();
		}

		~Scalar()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		private void Dispose(bool disposing)
		{
			if (handle != IntPtr.Zero)
			{
				NativeMethods.THSTorch_dispose_scalar(handle);
				handle = IntPtr.Zero;
			}
		}
	}
	public static class ScalarExtensionMethods
	{
		public static Scalar ToScalar(this byte value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_uint8_to_scalar(value));
		}

		public static Scalar ToScalar(this sbyte value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_int8_to_scalar(value));
		}

		public static Scalar ToScalar(this short value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_int16_to_scalar(value));
		}

		public static Scalar ToScalar(this int value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_int32_to_scalar(value));
		}

		public static Scalar ToScalar(this long value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_int64_to_scalar(value));
		}

		public static Scalar ToScalar(this float value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_float32_to_scalar(value));
		}

		public static Scalar ToScalar(this double value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_float64_to_scalar(value));
		}

		public static Scalar ToScalar(this (float, float) value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_complex32_to_scalar(value.Item1, value.Item2));
		}

		public static Scalar ToScalar(this Complex value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_complex64_to_scalar(value.Real, value.Imaginary));
		}

		public static Scalar ToScalar(this bool value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_bool_to_scalar(value));
		}

		public static Scalar ToBFloat16Scalar(this float value)
		{
			torch.InitializeDeviceType(DeviceType.CPU);
			return new Scalar(NativeMethods.THSTorch_bfloat16_to_scalar(value));
		}

		public static float ToSingle(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_float32(value.Handle);
		}

		public static double ToDouble(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_float64(value.Handle);
		}

		public static sbyte ToSByte(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_int8(value.Handle);
		}

		public static byte ToByte(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_uint8(value.Handle);
		}

		public static short ToInt16(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_int16(value.Handle);
		}

		public static int ToInt32(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_int32(value.Handle);
		}

		public static long ToInt64(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_int64(value.Handle);
		}

		public static bool ToBoolean(this Scalar value)
		{
			return NativeMethods.THSTorch_scalar_to_bool(value.Handle);
		}

		public static (float Real, float Imaginary) ToComplexFloat32(this Scalar value)
		{
			NativeMethods.THSTorch_scalar_to_complex32(value.Handle, out var real, out var imaginary);
			torch.CheckForErrors();
			return (Real: real, Imaginary: imaginary);
		}

		public static Complex ToComplexFloat64(this Scalar value)
		{
			NativeMethods.THSTorch_scalar_to_complex64(value.Handle, out var real, out var imaginary);
			torch.CheckForErrors();
			return new Complex(real, imaginary);
		}
	}
	public enum compute_mode
	{
		use_mm_for_euclid_dist_if_necessary,
		use_mm_for_euclid_dist,
		donot_use_mm_for_euclid_dist
	}
	public enum DebugMode
	{
		@default,
		warn
	}
	public enum Float32MatmulPrecision
	{
		highest,
		high,
		medium
	}
	public enum HistogramBinSelector : byte
	{
		Doane,
		Rice,
		Scott,
		Sqrt,
		Stone,
		Sturges
	}
	public enum indexing
	{
		xy,
		ij
	}
	public enum layout
	{
		strided,
		sparse_coo
	}
	public enum LobpcgMethod
	{
		basic,
		ortho
	}
	public enum memory_format
	{
		preserve_format,
		contiguous_format,
		channels_last
	}
	public enum PrintOptionsProfile
	{
		@default,
		@short,
		full
	}
	public enum Reduce
	{
		prod,
		mean,
		amax,
		amin
	}
	public enum TensorStringStyle
	{
		Metadata,
		Julia,
		Numpy,
		CSharp,
		Default
	}
	public static class TensorExtensionMethods
	{
		public static Parameter AsParameter(this torch.Tensor tensor)
		{
			return new Parameter(tensor);
		}

		public static string str(this torch.Tensor tensor, string? fltFormat = null, int? width = null, string? newLine = null, CultureInfo? cultureInfo = null, TensorStringStyle style = TensorStringStyle.Default)
		{
			return tensor.ToString(style, fltFormat, width, cultureInfo, newLine);
		}

		public static string jlstr(this torch.Tensor tensor, string? fltFormat = null, int? width = null, string? newLine = null, CultureInfo? cultureInfo = null)
		{
			return tensor.ToString(TensorStringStyle.Julia, fltFormat, width, cultureInfo, newLine);
		}

		public static string metastr(this torch.Tensor tensor)
		{
			return tensor.ToString(TensorStringStyle.Metadata);
		}

		public static string npstr(this torch.Tensor tensor, string? fltFormat = "g5", int? width = 100, string? newLine = null, CultureInfo? cultureInfo = null)
		{
			return tensor.ToString(TensorStringStyle.Numpy, fltFormat, width, cultureInfo, newLine);
		}

		public static string cstr(this torch.Tensor tensor, string? fltFormat = "g5", int? width = 100, string? newLine = null, CultureInfo? cultureInfo = null)
		{
			return tensor.ToString(TensorStringStyle.CSharp, fltFormat, width, cultureInfo, newLine);
		}

		public static torch.Tensor print(this torch.Tensor t, string? fltFormat = "g5", int? width = 100, string? newLine = null, CultureInfo? cultureInfo = null, TensorStringStyle style = TensorStringStyle.Default)
		{
			Console.WriteLine(t.ToString(style, fltFormat, width, cultureInfo, newLine));
			return t;
		}

		internal static bool IsIntegral(this torch.Tensor tensor)
		{
			return tensor.dtype.IsIntegral();
		}

		public static ReadOnlySpan<int> IntShape(this torch.Tensor tensor)
		{
			long[] shape = tensor.shape;
			int[] array = new int[shape.Length];
			for (int i = 0; i < shape.Length; i++)
			{
				array[i] = (int)shape[i];
			}
			return array;
		}

		public static int ElementSize(this torch.ScalarType type)
		{
			return type switch
			{
				torch.ScalarType.Byte => 1, 
				torch.ScalarType.Int8 => 1, 
				torch.ScalarType.Int16 => 2, 
				torch.ScalarType.Int32 => 4, 
				torch.ScalarType.Int64 => 8, 
				torch.ScalarType.Float16 => 2, 
				torch.ScalarType.Float32 => 4, 
				torch.ScalarType.Float64 => 8, 
				torch.ScalarType.ComplexFloat32 => 8, 
				torch.ScalarType.ComplexFloat64 => 16, 
				torch.ScalarType.Bool => 1, 
				torch.ScalarType.BFloat16 => 2, 
				_ => throw new NotImplementedException(), 
			};
		}

		internal static bool IsIntegral(this torch.ScalarType type)
		{
			if ((uint)type <= 4u || type == torch.ScalarType.Bool)
			{
				return true;
			}
			return false;
		}

		internal static bool IsFloatingPoint(this torch.ScalarType type)
		{
			if ((uint)(type - 5) <= 2u || type == torch.ScalarType.BFloat16)
			{
				return true;
			}
			return false;
		}

		internal static bool IsComplex(this torch.ScalarType type)
		{
			if ((uint)(type - 9) <= 1u)
			{
				return true;
			}
			return false;
		}

		public static void Save(this torch.Tensor tensor, BinaryWriter writer)
		{
			bool flag = false;
			if (tensor.device_type != DeviceType.CPU)
			{
				tensor = tensor.to(torch.CPU);
				flag = true;
			}
			writer.Encode((long)tensor.dtype);
			writer.Encode(tensor.shape.Length);
			long[] shape = tensor.shape;
			foreach (long value in shape)
			{
				writer.Encode(value);
			}
			tensor.WriteBytesToStream(writer.BaseStream);
			if (flag)
			{
				tensor.Dispose();
			}
		}

		public static void Save(this torch.Tensor tensor, Stream stream)
		{
			using BinaryWriter writer = new BinaryWriter(stream);
			tensor.Save(writer);
			stream.Flush();
		}

		public static void Save(this torch.Tensor tensor, string location)
		{
			tensor.Save(File.Create(location));
		}

		public static void Load(this torch.Tensor tensor, BinaryReader reader, bool skip = false)
		{
			if ((int)(sbyte)reader.Decode() != (int)tensor.dtype)
			{
				throw new ArgumentException("Mismatched tensor data types while loading. Make sure that the model you are loading into is exactly the same as the origin.");
			}
			long num = reader.Decode();
			long[] array = new long[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = reader.Decode();
			}
			if (!skip && !array.SequenceEqual(tensor.shape))
			{
				throw new ArgumentException("Mismatched tensor shape while loading. Make sure that the model you are loading into is exactly the same as the origin.");
			}
			if (!skip)
			{
				using (torch.no_grad())
				{
					if (tensor.device.type != DeviceType.CPU)
					{
						torch.Device cPU = torch.CPU;
						using torch.Tensor tensor2 = torch.zeros_like(tensor, null, cPU);
						tensor2.ReadBytesFromStream(reader.BaseStream);
						tensor.copy_(tensor2);
						return;
					}
					tensor.ReadBytesFromStream(reader.BaseStream);
					return;
				}
			}
			reader.BaseStream.Seek(tensor.NumberOfElements * tensor.ElementSize, SeekOrigin.Current);
		}

		public static torch.Tensor Load(BinaryReader reader, bool skip = false)
		{
			torch.Tensor tensor = null;
			Load(ref tensor, reader, skip);
			return tensor;
		}

		public static void Load(ref torch.Tensor? tensor, BinaryReader reader, bool skip = false)
		{
			torch.ScalarType value = (torch.ScalarType)reader.Decode();
			long num = reader.Decode();
			long[] array = new long[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = reader.Decode();
			}
			if ((object)tensor == null)
			{
				tensor = (skip ? torch.zeros(array, value) : torch.empty(array, value));
			}
			else if (!skip && !array.SequenceEqual(tensor.shape))
			{
				throw new ArgumentException("Mismatched tensor shape while loading. Make sure that the model you are loading into is exactly the same as the origin.");
			}
			if (!skip)
			{
				using (torch.no_grad())
				{
					if (tensor.device.type != DeviceType.CPU)
					{
						torch.Tensor? input = tensor;
						torch.Device cPU = torch.CPU;
						using torch.Tensor tensor2 = torch.zeros_like(input, null, cPU);
						tensor2.ReadBytesFromStream(reader.BaseStream);
						tensor.copy_(tensor2);
						return;
					}
					tensor.ReadBytesFromStream(reader.BaseStream);
					return;
				}
			}
			reader.BaseStream.Seek(tensor.NumberOfElements * tensor.ElementSize, SeekOrigin.Current);
		}

		public static torch.Tensor ToTensor<T>(this T[] rawArray, long[] dimensions, bool doCopy = false, bool requires_grad = false)
		{
			T[] array = (doCopy ? ((T[])rawArray.Clone()) : rawArray);
			if (typeof(T) == typeof(byte))
			{
				byte[] rawArray2 = array as byte[];
				ReadOnlySpan<long> dimensions2 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray2, dimensions2, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(sbyte))
			{
				sbyte[] rawArray3 = array as sbyte[];
				ReadOnlySpan<long> dimensions3 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray3, dimensions3, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(short))
			{
				short[] rawArray4 = array as short[];
				ReadOnlySpan<long> dimensions4 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray4, dimensions4, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(int))
			{
				int[] rawArray5 = array as int[];
				ReadOnlySpan<long> dimensions5 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray5, dimensions5, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(long))
			{
				long[] dataArray = array as long[];
				ReadOnlySpan<long> dimensions6 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(dataArray, dimensions6, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(double))
			{
				double[] rawArray6 = array as double[];
				ReadOnlySpan<long> dimensions7 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray6, dimensions7, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(float))
			{
				float[] rawArray7 = array as float[];
				ReadOnlySpan<long> dimensions8 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray7, dimensions8, null, null, requires_grad2);
			}
			if (typeof(T) == typeof(bool))
			{
				bool[] rawArray8 = array as bool[];
				ReadOnlySpan<long> dimensions9 = dimensions;
				bool requires_grad2 = requires_grad;
				return torch.tensor(rawArray8, dimensions9, null, null, requires_grad2);
			}
			throw new NotImplementedException($"Creating tensor of type {typeof(T)} is not supported.");
		}

		public static torch.Tensor ToTensor<T>(this T scalar, torch.Device? device = null, bool requires_grad = false) where T : struct
		{
			if (requires_grad && typeof(T) != typeof(float) && typeof(T) != typeof(double))
			{
				throw new ArgumentException("requires_grad", "Only floating point types support gradients.");
			}
			if (typeof(T) == typeof(byte))
			{
				return torch.tensor((byte)(object)scalar, torch.uint8, device, requires_grad);
			}
			if (typeof(T) == typeof(sbyte))
			{
				return torch.tensor((sbyte)(object)scalar, torch.int8, device, requires_grad);
			}
			if (typeof(T) == typeof(short))
			{
				return torch.tensor((short)(object)scalar, torch.int16, device, requires_grad);
			}
			if (typeof(T) == typeof(int))
			{
				return torch.tensor((int)(object)scalar, torch.int32, device, requires_grad);
			}
			if (typeof(T) == typeof(long))
			{
				return torch.tensor((long)(object)scalar, torch.int64, device, requires_grad);
			}
			if (typeof(T) == typeof(float))
			{
				return torch.tensor((float)(object)scalar, torch.float32, device, requires_grad);
			}
			if (typeof(T) == typeof(double))
			{
				return torch.tensor((double)(object)scalar, torch.float64, device, requires_grad);
			}
			throw new NotImplementedException($"Creating tensor of type {typeof(T)} is not supported.");
		}

		public static (float Real, float Imaginary) ToComplexFloat32(this torch.Tensor value)
		{
			return value.ToScalar().ToComplexFloat32();
		}

		public static Complex ToComplexFloat64(this torch.Tensor value)
		{
			return value.ToScalar().ToComplexFloat64();
		}

		public static float ToSingle(this torch.Tensor value)
		{
			return value.ToScalar().ToSingle();
		}

		public static double ToDouble(this torch.Tensor value)
		{
			return value.ToScalar().ToDouble();
		}

		public static sbyte ToSByte(this torch.Tensor value)
		{
			return value.ToScalar().ToSByte();
		}

		public static byte ToByte(this torch.Tensor value)
		{
			return value.ToScalar().ToByte();
		}

		public static short ToInt16(this torch.Tensor value)
		{
			return value.ToScalar().ToInt16();
		}

		public static int ToInt32(this torch.Tensor value)
		{
			return value.ToScalar().ToInt32();
		}

		public static long ToInt64(this torch.Tensor value)
		{
			return value.ToScalar().ToInt64();
		}

		public static bool ToBoolean(this torch.Tensor value)
		{
			return value.ToScalar().ToBoolean();
		}

		public static (float Real, float Imaginary) ToComplex32(this torch.Tensor value)
		{
			return value.ToScalar().ToComplexFloat32();
		}

		public static Complex ToComplex64(this torch.Tensor value)
		{
			return value.ToScalar().ToComplexFloat64();
		}

		public static long TotalSize(this IEnumerable<long> shape)
		{
			long num = 1L;
			foreach (long item in shape)
			{
				num *= item;
			}
			return num;
		}

		internal static bool toWillCopy(this torch.Tensor tensor, torch.Device device)
		{
			return tensor.toWillCopy(device.type, device.index);
		}

		internal static bool toWillCopy(this torch.Tensor tensor, DeviceType deviceType, int deviceIndex)
		{
			if (tensor.device_index == deviceIndex)
			{
				return tensor.device_type != deviceType;
			}
			return true;
		}

		internal static bool toWillCopy(this torch.Tensor tensor, torch.ScalarType dtype)
		{
			return tensor.dtype != dtype;
		}

		internal static bool toWillCopy(this torch.Tensor tensor, torch.ScalarType dtype, torch.Device device)
		{
			return tensor.toWillCopy(dtype, device.type, device.index);
		}

		internal static bool toWillCopy(this torch.Tensor tensor, torch.ScalarType dtype, DeviceType deviceType, int deviceIndex)
		{
			if (tensor.device_index == deviceIndex && tensor.device_type == deviceType)
			{
				return tensor.dtype != dtype;
			}
			return true;
		}
	}
	public class ThreadDisposeScopeStatistics
	{
		public long CreatedOutsideScopeCount => TensorStatistics.CreatedOutsideScopeCount + PackedSequenceStatistics.CreatedOutsideScopeCount;

		public long DisposedOutsideScopeCount => TensorStatistics.DisposedOutsideScopeCount + PackedSequenceStatistics.DisposedOutsideScopeCount;

		public long CreatedInScopeCount => TensorStatistics.CreatedInScopeCount + PackedSequenceStatistics.CreatedInScopeCount;

		public long DisposedInScopeCount => TensorStatistics.DisposedInScopeCount + PackedSequenceStatistics.DisposedInScopeCount;

		public long AttachedToScopeCount => TensorStatistics.AttachedToScopeCount + PackedSequenceStatistics.AttachedToScopeCount;

		public long DetachedFromScopeCount => TensorStatistics.DetachedFromScopeCount + PackedSequenceStatistics.DetachedFromScopeCount;

		public long ThreadTotalLiveCount => TensorStatistics.ThreadTotalLiveCount + PackedSequenceStatistics.ThreadTotalLiveCount;

		public LifetimeStatistics TensorStatistics { get; } = new LifetimeStatistics();

		public LifetimeStatistics PackedSequenceStatistics { get; } = new LifetimeStatistics();

		public void Reset()
		{
			TensorStatistics.Reset();
			PackedSequenceStatistics.Reset();
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("ThreadTotalLiveCount: " + ThreadTotalLiveCount);
			stringBuilder.Append("; CreatedOutsideScopeCount: " + CreatedOutsideScopeCount);
			stringBuilder.Append("; DisposedOutsideScopeCount: " + DisposedOutsideScopeCount);
			stringBuilder.Append("; CreatedInScopeCount: " + CreatedInScopeCount);
			stringBuilder.Append("; DisposedInScopeCount: " + DisposedInScopeCount);
			stringBuilder.Append("; AttachedToScopeCount: " + AttachedToScopeCount);
			stringBuilder.Append("; DetachedFromScopeCount: " + DetachedFromScopeCount);
			return stringBuilder.ToString();
		}
	}
	public class LifetimeStatistics
	{
		public long CreatedOutsideScopeCount { get; internal set; }

		public long DisposedOutsideScopeCount { get; internal set; }

		public long CreatedInScopeCount { get; internal set; }

		public long DisposedInScopeCount { get; internal set; }

		public long AttachedToScopeCount { get; internal set; }

		public long DetachedFromScopeCount { get; internal set; }

		public long ThreadTotalLiveCount => CreatedInScopeCount - DisposedInScopeCount + (CreatedOutsideScopeCount - DisposedOutsideScopeCount);

		public void Reset()
		{
			CreatedOutsideScopeCount = 0L;
			DisposedOutsideScopeCount = 0L;
			CreatedInScopeCount = 0L;
			DisposedInScopeCount = 0L;
			AttachedToScopeCount = 0L;
			DetachedFromScopeCount = 0L;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("ThreadTotalLiveCount: " + ThreadTotalLiveCount);
			stringBuilder.Append("; CreatedOutsideScopeCount: " + CreatedOutsideScopeCount);
			stringBuilder.Append("; DisposedOutsideScopeCount: " + DisposedOutsideScopeCount);
			stringBuilder.Append("; CreatedInScopeCount: " + CreatedInScopeCount);
			stringBuilder.Append("; DisposedInScopeCount: " + DisposedInScopeCount);
			stringBuilder.Append("; AttachedToScopeCount: " + AttachedToScopeCount);
			stringBuilder.Append("; DetachedFromScopeCount: " + DetachedFromScopeCount);
			return stringBuilder.ToString();
		}
	}
	public enum DeviceType
	{
		CPU = 0,
		CUDA = 1,
		MKLDNN = 2,
		OPENGL = 3,
		OPENCL = 4,
		IDEEP = 5,
		HIP = 6,
		FPGA = 7,
		MSNPU = 8,
		XLA = 9,
		MPS = 13,
		META = 14
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public delegate IntPtr AllocateIndexedNativeTensorOrScalarArray(int id, IntPtr length);
	internal sealed class NativeTensorOrScalarIndexedArray : IDisposable
	{
		private List<IntPtr> arrays = new List<IntPtr>();

		private List<int> sizes = new List<int>();

		private int _allocated;

		public int Count => arrays.Count;

		public IntPtr this[int idx] => arrays[idx];

		public IntPtr this[int idx, int size]
		{
			set
			{
				ExtendHandlesList(idx);
				arrays[idx] = value;
				sizes[idx] = size;
			}
		}

		public IntPtr CreateArray(int index, int length)
		{
			IntPtr intPtr = NativeMethods.THSJIT_AllocateTensorOrScalarArray(length);
			torch.CheckForErrors();
			_allocated++;
			this[index, length] = intPtr;
			return intPtr;
		}

		internal unsafe static TensorOrScalar ToTOS(IntPtr handle, int index)
		{
			TensorOrScalar* ptr = (TensorOrScalar*)(void*)NativeMethods.THSJIT_GetTensorOrScalar(handle, index);
			torch.CheckForErrors();
			return new TensorOrScalar
			{
				Handle = ptr->Handle,
				ArrayIndex = ptr->ArrayIndex,
				TypeCode = ptr->TypeCode
			};
		}

		public TensorOrScalar[] ToToSArray(int index)
		{
			int num = sizes[index];
			IntPtr handle = arrays[index];
			TensorOrScalar[] array = new TensorOrScalar[num];
			for (int i = 0; i < num; i++)
			{
				array[i] = ToTOS(handle, i);
			}
			return array;
		}

		public IntPtr CreateArray(int index, IntPtr length)
		{
			return CreateArray(index, (int)length);
		}

		public void Dispose()
		{
			FreeHandles();
		}

		~NativeTensorOrScalarIndexedArray()
		{
			FreeHandles();
		}

		private void ExtendHandlesList(int idx)
		{
			if (idx >= arrays.Count)
			{
				int num = idx - arrays.Count + 1;
				for (int i = 0; i < num; i++)
				{
					arrays.Add(IntPtr.Zero);
					sizes.Add(0);
				}
			}
		}

		private void FreeHandles()
		{
			foreach (IntPtr array in arrays)
			{
				if (array != IntPtr.Zero)
				{
					NativeMethods.THSJIT_FreeTensorOrScalarArray(array);
					torch.CheckForErrors();
					_allocated--;
				}
			}
			arrays.Clear();
		}
	}
	internal static class OverloadHelper
	{
		public static IntPtr[] ToHandleArray(this ReadOnlySpan<torch.Tensor> span)
		{
			if (span.Length == 0)
			{
				return Array.Empty<IntPtr>();
			}
			IntPtr[] array = new IntPtr[span.Length];
			for (int i = 0; i < span.Length; i++)
			{
				array[i] = span[i].Handle;
			}
			return array;
		}

		public static IntPtr[] ToHandleArray(this IList<torch.Tensor> list)
		{
			if (list.Count == 0)
			{
				return Array.Empty<IntPtr>();
			}
			IntPtr[] array = new IntPtr[list.Count];
			for (int i = 0; i < list.Count; i++)
			{
				array[i] = list[i].Handle;
			}
			return array;
		}

		public static IntPtr[] ToHandleArray(this torch.Tensor[] array)
		{
			return ((ReadOnlySpan<torch.Tensor>)array).ToHandleArray();
		}

		public static IntPtr[] ToHandleArray(this IEnumerable<torch.Tensor> enumerable)
		{
			return enumerable.Select((torch.Tensor t) => t.Handle).ToArray();
		}
	}
	internal sealed class PinnedArray<T> : IDisposable where T : struct
	{
		private GCHandle handle;

		public T[] Array { get; private set; }

		public IntPtr CreateArray(int length)
		{
			FreeHandle();
			Array = new T[length];
			try
			{
			}
			finally
			{
				handle = GCHandle.Alloc(Array, GCHandleType.Pinned);
			}
			return handle.AddrOfPinnedObject();
		}

		public IntPtr CreateArray(IntPtr length)
		{
			return CreateArray((int)length);
		}

		public IntPtr CreateArray(T[] array)
		{
			FreeHandle();
			Array = array;
			try
			{
			}
			finally
			{
				handle = GCHandle.Alloc(Array, GCHandleType.Pinned);
			}
			return handle.AddrOfPinnedObject();
		}

		public void Dispose()
		{
			if (Array != null)
			{
				T[] array = Array;
				for (int i = 0; i < array.Length; i++)
				{
					(array[i] as IDisposable)?.Dispose();
				}
			}
			FreeHandle();
		}

		~PinnedArray()
		{
			FreeHandle();
		}

		private void FreeHandle()
		{
			if (handle.IsAllocated)
			{
				handle.Free();
			}
		}
	}
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	public delegate IntPtr AllocatePinnedArray(IntPtr length);
}
namespace TorchSharp.Utils
{
	public class BigEndianReader
	{
		private BinaryReader mBaseReader;

		public Stream BaseStream => mBaseReader.BaseStream;

		public BigEndianReader(BinaryReader baseReader)
		{
			mBaseReader = baseReader;
		}

		public int ReadInt32()
		{
			return BitConverter.ToInt32(ReadBigEndianBytes(4), 0);
		}

		public byte[] ReadBigEndianBytes(int count)
		{
			byte[] array = new byte[count];
			for (int num = count - 1; num >= 0; num--)
			{
				array[num] = mBaseReader.ReadByte();
			}
			return array;
		}

		public byte[] ReadBytes(int count)
		{
			return mBaseReader.ReadBytes(count);
		}

		public void Close()
		{
			mBaseReader.Close();
		}
	}
	public class ComponentNameAttribute : Attribute
	{
		public string Name { get; set; }
	}
	public static class CRC32C
	{
		public unsafe static uint process(byte[] data)
		{
			fixed (byte* ptr = data)
			{
				return NativeMethods.crc32c_append(0u, (IntPtr)ptr, (ulong)data.Length);
			}
		}

		public unsafe static uint process(int data)
		{
			fixed (int* ptr = stackalloc int[1] { data })
			{
				return NativeMethods.crc32c_append(0u, (IntPtr)ptr, 4uL);
			}
		}

		public unsafe static uint process(long data)
		{
			fixed (long* ptr = stackalloc long[1] { data })
			{
				return NativeMethods.crc32c_append(0u, (IntPtr)ptr, 8uL);
			}
		}
	}
	public static class Decompress
	{
		public static void DecompressGZipFile(string gzipFileName, string targetDir)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Expected O, but got Unknown
			byte[] array = new byte[4096];
			using FileStream fileStream = File.OpenRead(gzipFileName);
			GZipInputStream val = new GZipInputStream((Stream)fileStream);
			try
			{
				using FileStream fileStream2 = File.Create(Path.Combine(targetDir, Path.GetFileNameWithoutExtension(gzipFileName)));
				StreamUtils.Copy((Stream)(object)val, (Stream)fileStream2, array);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		public static void ExtractTGZ(string gzArchiveName, string destFolder)
		{
			string path = gzArchiveName.Split(new char[1] { Path.DirectorySeparatorChar }).Last().Split(new char[1] { '.' })
				.First() + ".bin";
			if (File.Exists(Path.Combine(destFolder, path)))
			{
				return;
			}
			Console.WriteLine("Extracting.");
			Task task = Task.Run(delegate
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Expected O, but got Unknown
				using FileStream fileStream = File.OpenRead(gzArchiveName);
				GZipInputStream val = new GZipInputStream((Stream)fileStream);
				try
				{
					TarArchive val2 = TarArchive.CreateInputTarArchive((Stream)(object)val);
					try
					{
						val2.ExtractContents(destFolder);
					}
					finally
					{
						((IDisposable)val2)?.Dispose();
					}
				}
				finally
				{
					((IDisposable)val)?.Dispose();
				}
			});
			while (!task.IsCompleted)
			{
				Thread.Sleep(200);
				Console.Write(".");
			}
			File.Create(Path.Combine(destFolder, path));
			Console.WriteLine("");
			Console.WriteLine("Extraction completed.");
		}
	}
	internal class FastShuffler : IEnumerable<long>, IEnumerable
	{
		private class ShuffleEnumerator : IEnumerator<long>, IEnumerator, IDisposable
		{
			private long maxrange;

			private long prime;

			private long index;

			private long offset;

			private long runningvalue;

			private Random rand;

			private int? seed;

			private long size;

			private const long MAX_COUNT = long.MaxValue;

			object IEnumerator.Current => Current;

			public long Current => runningvalue;

			public ShuffleEnumerator(long size, int? seed = null)
			{
				this.seed = seed;
				this.size = size;
				Reset();
			}

			private long SelectCoPrimeResev(long min, long target)
			{
				long num = 0L;
				long result = 0L;
				for (long num2 = min; num2 < target; num2++)
				{
					if (Coprime(num2, target))
					{
						num++;
						if (num == 1 || NextLong(rand, num) < 1)
						{
							result = num2;
						}
					}
					if (num == long.MaxValue)
					{
						return num2;
					}
				}
				return result;
			}

			private static bool Coprime(long u, long v)
			{
				return Gcd(u, v) == 1;
			}

			private static long Gcd(long a, long b)
			{
				while (a != 0L && b != 0L)
				{
					if (a > b)
					{
						a %= b;
					}
					else
					{
						b %= a;
					}
				}
				return a | b;
			}

			private static long NextLong(Random r, long l)
			{
				byte[] array = new byte[8];
				r.NextBytes(array);
				long num = 0L;
				byte[] array2 = array;
				foreach (byte b in array2)
				{
					num <<= 8;
					num += b;
				}
				return num % l;
			}

			public bool MoveNext()
			{
				if (index >= maxrange)
				{
					return false;
				}
				runningvalue += prime;
				if (runningvalue >= maxrange)
				{
					runningvalue -= maxrange;
				}
				index++;
				return true;
			}

			public void Reset()
			{
				int? num = seed;
				rand = ((!num.HasValue) ? new Random() : new Random(seed.Value));
				long min = size / 2;
				maxrange = size;
				prime = SelectCoPrimeResev(min, size);
				offset = NextLong(rand, size);
				index = 0L;
				runningvalue = offset;
			}

			public void Dispose()
			{
			}
		}

		private long size;

		private int? seed;

		public FastShuffler(long size, int? seed = null)
		{
			this.size = size;
			this.seed = seed;
		}

		public IEnumerator<long> GetEnumerator()
		{
			return new ShuffleEnumerator(size, seed);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class FisherYatesShuffler : IEnumerable<long>, IEnumerable
	{
		private class FisherYatesShufflerEnumerable : IEnumerator<long>, IEnumerator, IDisposable
		{
			private int? seed;

			private long size;

			private Dictionary<long, long> indexs = new Dictionary<long, long>();

			private Random r;

			private long current = -1L;

			public long Current => indexs[current];

			object IEnumerator.Current => Current;

			public FisherYatesShufflerEnumerable(long size)
			{
				this.size = size;
				seed = null;
				Reset();
			}

			public FisherYatesShufflerEnumerable(long size, int seed)
			{
				this.size = size;
				this.seed = seed;
				Reset();
			}

			public bool MoveNext()
			{
				current++;
				return current < size;
			}

			public void Reset()
			{
				r = ((!seed.HasValue) ? new Random() : new Random(seed.Value));
				current = -1L;
				indexs.Clear();
				for (long num = 0L; num < size; num++)
				{
					long randomLong = GetRandomLong(num);
					if (randomLong == num)
					{
						indexs[num] = num;
						continue;
					}
					indexs[num] = indexs[randomLong];
					indexs[randomLong] = num;
				}
			}

			public void Dispose()
			{
			}

			private long GetRandomLong(long l)
			{
				return (((long)r.Next() << 32) + (uint)r.Next()) % (l + 1);
			}
		}

		private long size;

		private int? seed;

		public FisherYatesShuffler(long size, int? seed = null)
		{
			this.size = size;
			this.seed = seed;
		}

		public IEnumerator<long> GetEnumerator()
		{
			if (seed.HasValue)
			{
				return new FisherYatesShufflerEnumerable(size, seed.Value);
			}
			return new FisherYatesShufflerEnumerable(size);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	internal static class Histogram
	{
		private static Dictionary<HistogramBinSelector, Func<torch.Tensor, (double min, double max)?, torch.Tensor>> histBinSelectors = new Dictionary<HistogramBinSelector, Func<torch.Tensor, (double, double)?, torch.Tensor>>
		{
			{
				HistogramBinSelector.Stone,
				HistBinStone
			},
			{
				HistogramBinSelector.Doane,
				HistBinDoane
			},
			{
				HistogramBinSelector.Rice,
				HistBinRice
			},
			{
				HistogramBinSelector.Scott,
				HistBinScott
			},
			{
				HistogramBinSelector.Sqrt,
				HistBinSqrt
			},
			{
				HistogramBinSelector.Sturges,
				HistBinSturges
			}
		};

		public static (torch.Tensor hist, torch.Tensor bin_edges) histogram(torch.Tensor input, HistogramBinSelector bins, (double min, double max)? range, bool density = false)
		{
			input = RavelAndCheckWeights(input.cpu());
			(torch.Tensor, (double, double, int)) binEdges = GetBinEdges(input, bins, range);
			torch.Tensor item = binEdges.Item1;
			(double, double, int) item2 = binEdges.Item2;
			torch.ScalarType scalarType = torch.ScalarType.Int32;
			int num = 65536;
			double item3 = item2.Item1;
			double item4 = item2.Item2;
			int item5 = item2.Item3;
			torch.Tensor tensor = torch.zeros(item5, scalarType);
			torch.Tensor tensor2 = item5 / torch.subtract(item4, item3);
			for (int i = 0; i < input.shape[0]; i += num)
			{
				torch.Tensor tensor3 = input[new torch.TensorIndex[1] { torch.TensorIndex.Slice(i, i + num) }];
				torch.Tensor tensor4 = tensor3 >= item3;
				tensor4 &= tensor3 <= item4;
				if (tensor4.sum().item<long>() != tensor3.numel())
				{
					tensor3 = tensor3.masked_select(tensor4);
				}
				tensor3 = tensor3.to_type(item.dtype);
				torch.Tensor tensor5 = (torch.subtract(tensor3, item3) * tensor2).to_type(torch.ScalarType.Int64);
				tensor5[new torch.Tensor[1] { tensor5 == item5 }] -= 1;
				torch.Tensor tensor6 = tensor3 < item[new torch.Tensor[1] { tensor5 }];
				tensor5[new torch.Tensor[1] { tensor6 }] -= 1;
				torch.Tensor tensor7 = (tensor3 >= item[new torch.Tensor[1] { tensor5 + 1 }]) & (tensor5 != item5 - 1);
				tensor5[new torch.Tensor[1] { tensor7 }] += 1;
				tensor += torch.bincount(tensor5, null, item5).to_type(scalarType);
			}
			if (density)
			{
				torch.Tensor tensor8 = torch.diff(item, 1L, -1L).to_type(torch.ScalarType.Float32);
				return (hist: tensor / tensor8 / tensor.sum(), bin_edges: item);
			}
			return (hist: tensor, bin_edges: item);
		}

		private static (torch.Tensor, (double, double, int)) GetBinEdges(torch.Tensor a, HistogramBinSelector bins, (double min, double max)? range)
		{
			var (num, num2) = GetOuterEdges(a, range);
			if (range.HasValue)
			{
				torch.Tensor tensor = a >= num;
				tensor &= a <= num2;
				if (tensor.sum().item<long>() != a.numel())
				{
					a = a.masked_select(tensor);
				}
			}
			int num3;
			if (a.numel() == 0L)
			{
				num3 = 1;
			}
			else
			{
				if (a.dtype != torch.ScalarType.Float64)
				{
					a = a.to_type(torch.ScalarType.Float64);
				}
				torch.Tensor tensor2 = histBinSelectors[bins](a, range);
				num3 = ((!(tensor2 > 0).item<bool>()) ? 1 : torch.ceil(torch.subtract(num2, num) / tensor2).to_type(torch.ScalarType.Int32).item<int>());
			}
			return (torch.linspace(num, num2, num3 + 1, torch.ScalarType.Float64, null, requires_grad: true), (num, num2, num3));
		}

		private static (double, double) GetOuterEdges(torch.Tensor a, (double min, double max)? range)
		{
			double num;
			double num2;
			if (range.HasValue)
			{
				(num, num2) = range.Value;
				if (num > num2)
				{
					throw new ArgumentException("max must be larger than min in range parameter.");
				}
				if (double.IsInfinity(num) || double.IsNaN(num) || double.IsInfinity(num2) || double.IsNaN(num2))
				{
					throw new ArgumentException($"supplied range of [{num}, {num2}] is not finite");
				}
			}
			else if (a.numel() == 0L)
			{
				num = 0.0;
				num2 = 1.0;
			}
			else
			{
				double num3 = a.min().to_type(torch.ScalarType.Float64).item<double>();
				double num4 = a.max().to_type(torch.ScalarType.Float64).item<double>();
				num = num3;
				num2 = num4;
				if (double.IsInfinity(num) || double.IsNaN(num) || double.IsInfinity(num2) || double.IsNaN(num2))
				{
					throw new ArgumentException($"autodetected range of [{num}, {num2}] is not finite");
				}
			}
			if (num == num2)
			{
				double num3 = num - 0.5;
				double num5 = num2 + 0.5;
				num = num3;
				num2 = num5;
			}
			return (num, num2);
		}

		private static torch.Tensor RavelAndCheckWeights(torch.Tensor input)
		{
			if (input.dtype == torch.ScalarType.Bool)
			{
				input = input.to_type(torch.ScalarType.Int8);
			}
			input = input.ravel();
			return input;
		}

		private static torch.Tensor HistBinSqrt(torch.Tensor x, (double min, double max)? _)
		{
			return Ptp(x) / torch.sqrt(x.numel());
		}

		private static torch.Tensor HistBinSturges(torch.Tensor x, (double min, double max)? _)
		{
			return Ptp(x) / (torch.log2(x.numel()) + 1);
		}

		private static torch.Tensor HistBinRice(torch.Tensor x, (double min, double max)? _)
		{
			return Ptp(x) / (2 * torch.pow(x.numel(), 1.0 / 3.0));
		}

		private static torch.Tensor HistBinScott(torch.Tensor x, (double min, double max)? _)
		{
			return Math.Pow(24.0 * Math.Pow(Math.PI, 0.5) / (double)x.numel(), 1.0 / 3.0) * torch.std(x, unbiased: false);
		}

		private static torch.Tensor HistBinStone(torch.Tensor x, (double min, double max)? range)
		{
			long n = x.numel();
			torch.Tensor ptp_x = Ptp(x);
			if (n <= 1 || (ptp_x == 0).item<bool>())
			{
				return 0;
			}
			int num = Math.Max(100, Convert.ToInt32(Math.Sqrt(n)));
			int num2 = 0;
			double num3 = double.PositiveInfinity;
			foreach (int item in Enumerable.Range(1, num + 1))
			{
				double num4 = Jhat(item);
				if (num4 < num3)
				{
					num3 = num4;
					num2 = item;
				}
			}
			return ptp_x / num2;
			double Jhat(int nbins)
			{
				torch.Tensor tensor = ptp_x / nbins;
				torch.Tensor tensor2 = torch.histogram(x, nbins, range).hist / n;
				return ((2 - (n + 1) * tensor2.dot(tensor2)) / tensor).to_type(torch.ScalarType.Float64).item<double>();
			}
		}

		private static torch.Tensor HistBinDoane(torch.Tensor x, (double min, double max)? _)
		{
			long num = x.numel();
			if (num > 2)
			{
				torch.Tensor tensor = torch.sqrt(6.0 * (double)(num - 2) / (((double)num + 1.0) * (double)(num + 3)));
				torch.Tensor tensor2 = x.std();
				if ((tensor2 > 0.0).item<bool>())
				{
					torch.Tensor input = torch.float_power(torch.true_divide(x - x.mean(), tensor2), 3).mean();
					return Ptp(x) / (1.0 + torch.log2(num) + torch.log2(1.0 + torch.absolute(input) / tensor));
				}
			}
			return 0.0;
		}

		private static torch.Tensor Ptp(torch.Tensor input)
		{
			return torch.subtract(input.max(), input.min());
		}
	}
	internal static class LEB128Codec
	{
		public static IList<byte> Encode(long value)
		{
			if (value < 0)
			{
				throw new NotImplementedException("LEB128 encoding of negative numbers");
			}
			List<byte> list = new List<byte>();
			long num;
			while (true)
			{
				num = value & 0x7F;
				value >>= 7;
				if (value == 0L)
				{
					break;
				}
				list.Add((byte)(num | 0x80));
			}
			list.Add((byte)num);
			return list;
		}

		public static void Encode(this BinaryWriter writer, long value)
		{
			if (value < 0)
			{
				throw new NotImplementedException("LEB128 encoding of negative numbers");
			}
			long num;
			while (true)
			{
				num = value & 0x7F;
				value >>= 7;
				if (value == 0L)
				{
					break;
				}
				writer.Write((byte)(num | 0x80));
			}
			writer.Write((byte)num);
		}

		public static long Decode(this BinaryReader reader)
		{
			long num = 0L;
			int num2 = 0;
			while (true)
			{
				long num3 = reader.ReadByte();
				num += (num3 & 0x7F) << num2 * 7;
				if ((num3 & 0x80) == 0L)
				{
					break;
				}
				num2++;
			}
			return num;
		}

		public static long Decode(IList<byte> input)
		{
			long num = 0L;
			for (int i = 0; i < input.Count; i++)
			{
				long num2 = input[i];
				num += (num2 & 0x7F) << i * 7;
				if ((num2 & 0x80) == 0L)
				{
					break;
				}
			}
			return num;
		}
	}
	[AttributeUsage(AttributeTargets.Class)]
	public class TypeFormatterSourceAttribute : Attribute
	{
		public Type FormatterSourceType { get; }

		public TypeFormatterSourceAttribute(Type formatterSourceType)
		{
			FormatterSourceType = formatterSourceType;
		}
	}
	internal class TypeFormatterSource
	{
		public IEnumerable<object> CreateTypeFormatters()
		{
			yield return new TensorPlainTextFormatter();
			yield return new TensorHTMLFormatter();
		}
	}
	internal class TensorPlainTextFormatter
	{
		public string MimeType => "text/plain";

		public bool Format(object instance, TextWriter writer)
		{
			if (!(instance is torch.Tensor tensor))
			{
				return false;
			}
			writer.Write(tensor.ToString(TensorStringStyle.Default));
			return true;
		}
	}
	internal class TensorHTMLFormatter
	{
		public string MimeType => "text/html";

		public bool Format(object instance, TextWriter writer)
		{
			if (!(instance is torch.Tensor tensor))
			{
				return false;
			}
			writer.Write("<div><pre>" + tensor.ToString(TensorStringStyle.Default) + "</pre></div>");
			return true;
		}
	}
	public class ReferenceEqualityComparer<T> : EqualityComparer<T> where T : class
	{
		private static IEqualityComparer<T> _defaultComparer;

		public new static IEqualityComparer<T> Default => _defaultComparer ?? (_defaultComparer = new ReferenceEqualityComparer<T>());

		public override bool Equals(T x, T y)
		{
			return x == y;
		}

		public override int GetHashCode(T obj)
		{
			return RuntimeHelpers.GetHashCode(obj);
		}
	}
	public class OrderedDict<TKey, TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IList<(TKey, TValue)>, ICollection<(TKey, TValue)>, IEnumerable<(TKey, TValue)>
	{
		private List<(TKey, TValue)> _list = new List<(TKey, TValue)>();

		private Dictionary<TKey, TValue> _dict = new Dictionary<TKey, TValue>();

		public (TKey, TValue) this[int index]
		{
			get
			{
				return _list[index];
			}
			set
			{
				var (key, _) = value;
				_list[index] = value;
				_dict[key] = value.Item2;
			}
		}

		public bool IsReadOnly => false;

		public ICollection<TKey> Keys => _list.Select(((TKey, TValue) kv) => kv.Item1).ToList();

		public ICollection<TValue> Values => _list.Select(((TKey, TValue) kv) => kv.Item2).ToList();

		public int Count => _dict.Count;

		public TValue this[TKey key]
		{
			get
			{
				return _dict[key];
			}
			set
			{
				_dict[key] = value;
				int num = _list.FindIndex(delegate((TKey, TValue) kv)
				{
					ref TKey item = ref kv.Item1;
					object obj = key;
					return item.Equals(obj);
				});
				if (num >= 0)
				{
					_list[num] = (key, value);
				}
				else
				{
					_list.Add((key, value));
				}
			}
		}

		public void clear()
		{
			_list.Clear();
			_dict.Clear();
		}

		public IEnumerator<(TKey, TValue)> items()
		{
			return _list.GetEnumerator();
		}

		public IEnumerable<TKey> keys()
		{
			return _dict.Keys;
		}

		public IEnumerable<TValue> values()
		{
			return _dict.Values;
		}

		public void Add((TKey, TValue) item)
		{
			_dict.Add(item.Item1, item.Item2);
			_list.Add(item);
		}

		public void Add(TKey key, TValue value)
		{
			_dict.Add(key, value);
			_list.Add((key, value));
		}

		public void Add(KeyValuePair<TKey, TValue> item)
		{
			_dict.Add(item.Key, item.Value);
			_list.Add((item.Key, item.Value));
		}

		public bool Contains((TKey, TValue) item)
		{
			return _list.Contains(item);
		}

		public void CopyTo((TKey, TValue)[] array, int arrayIndex)
		{
			_list.CopyTo(array, arrayIndex);
		}

		public int IndexOf((TKey, TValue) item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, (TKey, TValue) item)
		{
			_dict.Add(item.Item1, item.Item2);
			_list.Insert(index, item);
		}

		public bool Remove((TKey, TValue) item)
		{
			_dict.Remove(item.Item1);
			return _list.Remove(item);
		}

		public void RemoveAt(int index)
		{
			if (index >= _list.Count)
			{
				throw new IndexOutOfRangeException();
			}
			TKey item = _list[index].Item1;
			_list.RemoveAt(index);
			_dict.Remove(item);
		}

		public bool ContainsKey(TKey key)
		{
			return _dict.ContainsKey(key);
		}

		public bool Remove(TKey key)
		{
			_ = _dict[key];
			int index = _list.FindIndex(delegate((TKey, TValue) kv)
			{
				ref TKey item = ref kv.Item1;
				object obj = key;
				return item.Equals(obj);
			});
			_list.RemoveAt(index);
			return _dict.Remove(key);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return _dict.TryGetValue(key, out value);
		}

		public void Clear()
		{
			_dict.Clear();
			_list.Clear();
		}

		public bool Contains(KeyValuePair<TKey, TValue> item)
		{
			return _dict.ContainsKey(item.Key);
		}

		public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		public bool Remove(KeyValuePair<TKey, TValue> item)
		{
			return _dict.Remove(item.Key);
		}

		public IEnumerator<(TKey, TValue)> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			throw new NotImplementedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<KeyValuePair<TKey, TValue>>)this).GetEnumerator();
		}
	}
	internal static class StringEncoder
	{
		private static readonly Encoding s_utfEncoding = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false, throwOnInvalidBytes: false);

		internal static byte[] GetNullTerminatedUTF8ByteArray(string input)
		{
			byte[] array = new byte[s_utfEncoding.GetMaxByteCount(input.Length) + 1];
			int bytes = s_utfEncoding.GetBytes(input, 0, input.Length, array, 0);
			array[bytes] = 0;
			return array;
		}
	}
	public sealed class TensorAccessor<T> : IDisposable, IEnumerable<T>, IEnumerable where T : unmanaged
	{
		private class SimpleAtorImpl : IEnumerator<T>, IEnumerator, IDisposable
		{
			private TensorAccessor<T> _span;

			private readonly long _count;

			private readonly long _stride;

			private long _index;

			private long _offset;

			private T _current;

			public T Current => _current;

			object IEnumerator.Current => Current;

			public SimpleAtorImpl(TensorAccessor<T> span, long stride)
			{
				_span = span;
				_count = span.Count;
				_stride = stride;
				Reset();
			}

			public void Dispose()
			{
				_span = null;
				Reset();
			}

			public unsafe bool MoveNext()
			{
				if (_index < 0)
				{
					_index = 0L;
					_offset = 0L;
				}
				else
				{
					if (++_index >= _count)
					{
						Reset();
						return false;
					}
					_offset += _stride;
				}
				_current = ((T*)(void*)_span._tensor_data_ptr)[_offset];
				return true;
			}

			public void Reset()
			{
				_index = -1L;
				_offset = -1L;
				_current = default(T);
			}
		}

		private class GeneralAtorImpl : IEnumerator<T>, IEnumerator, IDisposable
		{
			private TensorAccessor<T> _span;

			private readonly long _count;

			private readonly long[] _shape;

			private readonly long[] _stride;

			private readonly long[] _inds;

			private long _index;

			private long _offset;

			public T Current { get; private set; }

			object IEnumerator.Current => Current;

			public GeneralAtorImpl(TensorAccessor<T> span, long[] stride)
			{
				_span = span;
				_count = span.Count;
				_shape = span._tensor.shape;
				_stride = stride;
				_inds = new long[stride.Length];
				Reset();
			}

			public void Dispose()
			{
				_span = null;
			}

			public unsafe bool MoveNext()
			{
				if (_index < 0)
				{
					_index = 0L;
					_offset = 0L;
					Array.Clear(_inds, 0, _inds.Length);
				}
				else
				{
					if (++_index >= _count)
					{
						Reset();
						return false;
					}
					int num = _inds.Length - 1;
					while (true)
					{
						_offset += _stride[num];
						if (++_inds[num] < _shape[num])
						{
							break;
						}
						_offset -= _inds[num] * _stride[num];
						_inds[num] = 0L;
						num--;
					}
				}
				Current = ((T*)(void*)_span._tensor_data_ptr)[_offset];
				return true;
			}

			public void Reset()
			{
				_index = -1L;
				_offset = -1L;
				Current = default(T);
			}
		}

		private torch.Tensor _tensor;

		private IntPtr _tensor_data_ptr;

		public long Count
		{
			get
			{
				if ((object)_tensor == null)
				{
					return 0L;
				}
				return _tensor.numel();
			}
		}

		public bool IsReadOnly => false;

		public unsafe T this[params long[] indices]
		{
			get
			{
				long num = 0L;
				if (indices.Length == 1)
				{
					num = indices[0];
					validate(num);
					T* ptr = (T*)(void*)_tensor_data_ptr;
					return ptr[TranslateIndex(num, _tensor)];
				}
				T* ptr2 = (T*)(void*)_tensor_data_ptr;
				return ptr2[TranslateIndex(indices, _tensor)];
			}
			set
			{
				long num = 0L;
				if (indices.Length == 1)
				{
					num = indices[0];
					validate(num);
					T* ptr = (T*)(void*)_tensor_data_ptr;
					ptr[TranslateIndex(indices, _tensor)] = value;
				}
				else
				{
					T* ptr2 = (T*)(void*)_tensor_data_ptr;
					ptr2[TranslateIndex(indices, _tensor)] = value;
				}
			}
		}

		internal TensorAccessor(torch.Tensor tensor)
		{
			if (tensor.device_type != DeviceType.CPU)
			{
				throw new InvalidOperationException("Reading data from non-CPU memory is not supported. Move or copy the tensor to the cpu before reading.");
			}
			long[] array = tensor.stride();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] < 0)
				{
					throw new NotImplementedException($"Negative tensor strides are not currently supported. tensor.strides({i}) == {array[i]}");
				}
			}
			IntPtr intPtr = NativeMethods.THSTensor_data(tensor.Handle);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			_tensor_data_ptr = intPtr;
			_tensor = tensor;
		}

		public T[] ToArray()
		{
			if (_tensor.ndim < 2)
			{
				return (T[])ToNDArray();
			}
			T[] array = new T[Count];
			CopyTo(array, 0, 0L);
			return array;
		}

		public unsafe Array ToNDArray()
		{
			long[] shape = _tensor.shape;
			long[] array = _tensor.stride();
			long ndim = _tensor.ndim;
			if ((ulong)ndim <= 6uL)
			{
				switch (ndim)
				{
				case 0L:
				{
					T[] array3 = new T[1];
					T* ptr2 = (T*)(void*)_tensor_data_ptr;
					array3[0] = *ptr2;
					return array3;
				}
				case 1L:
				{
					T[] array7 = new T[shape[0]];
					T* ptr6 = (T*)(void*)_tensor_data_ptr;
					long num33 = 0L;
					long num34 = 0L;
					while (num33 < shape[0])
					{
						array7[num33] = ptr6[num34];
						num33++;
						num34 += array[0];
					}
					return array7;
				}
				case 2L:
				{
					T[,] array4 = new T[(int)checked((nint)shape[0]), (int)checked((nint)shape[1])];
					T* ptr3 = (T*)(void*)_tensor_data_ptr;
					long num13 = 0L;
					long num14 = 0L;
					while (num13 < shape[0])
					{
						long num15 = 0L;
						long num16 = num14;
						while (num15 < shape[1])
						{
							array4[(int)checked((nint)num13), (int)checked((nint)num15)] = ptr3[num16];
							num15++;
							num16 += array[1];
						}
						num13++;
						num14 += array[0];
					}
					return array4;
				}
				case 3L:
				{
					T[,,] array6 = new T[(int)checked((nint)shape[0]), (int)checked((nint)shape[1]), (int)checked((nint)shape[2])];
					T* ptr5 = (T*)(void*)_tensor_data_ptr;
					long num27 = 0L;
					long num28 = 0L;
					while (num27 < shape[0])
					{
						long num29 = 0L;
						long num30 = num28;
						while (num29 < shape[1])
						{
							long num31 = 0L;
							long num32 = num30;
							while (num31 < shape[2])
							{
								array6[(int)checked((nint)num27), (int)checked((nint)num29), (int)checked((nint)num31)] = ptr5[num32];
								num31++;
								num32 += array[2];
							}
							num29++;
							num30 += array[1];
						}
						num27++;
						num28 += array[0];
					}
					return array6;
				}
				case 4L:
				{
					T[,,,] array8 = new T[(int)checked((nint)shape[0]), (int)checked((nint)shape[1]), (int)checked((nint)shape[2]), (int)checked((nint)shape[3])];
					T* ptr7 = (T*)(void*)_tensor_data_ptr;
					long num35 = 0L;
					long num36 = 0L;
					while (num35 < shape[0])
					{
						long num37 = 0L;
						long num38 = num36;
						while (num37 < shape[1])
						{
							long num39 = 0L;
							long num40 = num38;
							while (num39 < shape[2])
							{
								long num41 = 0L;
								long num42 = num40;
								while (num41 < shape[3])
								{
									array8[(int)checked((nint)num35), (int)checked((nint)num37), (int)checked((nint)num39), (int)checked((nint)num41)] = ptr7[num42];
									num41++;
									num42 += array[3];
								}
								num39++;
								num40 += array[2];
							}
							num37++;
							num38 += array[1];
						}
						num35++;
						num36 += array[0];
					}
					return array8;
				}
				case 5L:
				{
					T[,,,,] array5 = new T[(int)checked((nint)shape[0]), (int)checked((nint)shape[1]), (int)checked((nint)shape[2]), (int)checked((nint)shape[3]), (int)checked((nint)shape[4])];
					T* ptr4 = (T*)(void*)_tensor_data_ptr;
					long num17 = 0L;
					long num18 = 0L;
					while (num17 < shape[0])
					{
						long num19 = 0L;
						long num20 = num18;
						while (num19 < shape[1])
						{
							long num21 = 0L;
							long num22 = num20;
							while (num21 < shape[2])
							{
								long num23 = 0L;
								long num24 = num22;
								while (num23 < shape[3])
								{
									long num25 = 0L;
									long num26 = num24;
									while (num25 < shape[4])
									{
										array5[(int)checked((nint)num17), (int)checked((nint)num19), (int)checked((nint)num21), (int)checked((nint)num23), (int)checked((nint)num25)] = ptr4[num26];
										num25++;
										num26 += array[4];
									}
									num23++;
									num24 += array[3];
								}
								num21++;
								num22 += array[2];
							}
							num19++;
							num20 += array[1];
						}
						num17++;
						num18 += array[0];
					}
					return array5;
				}
				case 6L:
				{
					T[,,,,,] array2 = new T[(int)checked((nint)shape[0]), (int)checked((nint)shape[1]), (int)checked((nint)shape[2]), (int)checked((nint)shape[3]), (int)checked((nint)shape[4]), (int)checked((nint)shape[5])];
					T* ptr = (T*)(void*)_tensor_data_ptr;
					long num = 0L;
					long num2 = 0L;
					while (num < shape[0])
					{
						long num3 = 0L;
						long num4 = num2;
						while (num3 < shape[1])
						{
							long num5 = 0L;
							long num6 = num4;
							while (num5 < shape[2])
							{
								long num7 = 0L;
								long num8 = num6;
								while (num7 < shape[3])
								{
									long num9 = 0L;
									long num10 = num8;
									while (num9 < shape[4])
									{
										long num11 = 0L;
										long num12 = num10;
										while (num11 < shape[5])
										{
											array2[(int)checked((nint)num), (int)checked((nint)num3), (int)checked((nint)num5), (int)checked((nint)num7), (int)checked((nint)num9), (int)checked((nint)num11)] = ptr[num12];
											num11++;
											num12 += array[5];
										}
										num9++;
										num10 += array[4];
									}
									num7++;
									num8 += array[3];
								}
								num5++;
								num6 += array[2];
							}
							num3++;
							num4 += array[1];
						}
						num++;
						num2 += array[0];
					}
					return array2;
				}
				}
			}
			return ToNDArray(shape, array);
		}

		private unsafe Array ToNDArray(long[] shape, long[] strides)
		{
			Array array = Array.CreateInstance(typeof(T), shape);
			long[] array2 = new long[_tensor.ndim];
			long[] array3 = new long[_tensor.ndim];
			while (true)
			{
				T* ptr = (T*)(void*)_tensor_data_ptr;
				array.SetValue(ptr[array3[array.Rank - 1]], array2);
				for (int num = array.Rank - 1; num >= 0; num--)
				{
					if (array2[num] < shape[num] - 1)
					{
						array2[num]++;
						array3[num] += strides[num];
						for (int i = num; i < array.Rank - 1; i++)
						{
							array3[i + 1] = array3[i];
						}
						break;
					}
					if (num == 0)
					{
						return array;
					}
					array2[num] = 0L;
				}
			}
		}

		private void validate(long index)
		{
			if (index >= Count)
			{
				throw new IndexOutOfRangeException();
			}
		}

		public unsafe void CopyTo(T[] array, int arrayIndex = 0, long tensorIndex = 0L)
		{
			int num = arrayIndex;
			foreach (long subsequentIndex in GetSubsequentIndices(tensorIndex))
			{
				int num2 = (int)subsequentIndex;
				if (num >= array.Length)
				{
					break;
				}
				array[num] = ((T*)(void*)_tensor_data_ptr)[num2];
				num++;
			}
		}

		public unsafe void CopyTo(Span<T> array, int arrayIndex = 0, long tensorIndex = 0L)
		{
			int num = arrayIndex;
			foreach (long subsequentIndex in GetSubsequentIndices(tensorIndex))
			{
				int num2 = (int)subsequentIndex;
				if (num >= array.Length)
				{
					break;
				}
				array[num] = ((T*)(void*)_tensor_data_ptr)[num2];
				num++;
			}
		}

		public unsafe void CopyFrom(T[] array, int arrayIndex = 0, long tensorIndex = 0L)
		{
			int num = arrayIndex;
			foreach (long subsequentIndex in GetSubsequentIndices(tensorIndex))
			{
				int num2 = (int)subsequentIndex;
				if (num >= array.Length)
				{
					break;
				}
				((T*)(void*)_tensor_data_ptr)[num2] = array[num];
				num++;
			}
		}

		public unsafe void CopyFrom(ReadOnlySpan<T> array, int arrayIndex = 0, long tensorIndex = 0L)
		{
			int num = arrayIndex;
			foreach (long subsequentIndex in GetSubsequentIndices(tensorIndex))
			{
				int num2 = (int)subsequentIndex;
				if (num >= array.Length)
				{
					break;
				}
				((T*)(void*)_tensor_data_ptr)[num2] = array[num];
				num++;
			}
		}

		private static long TranslateIndex(long idx, torch.Tensor tensor)
		{
			if (idx >= tensor.numel() || idx < 0)
			{
				throw new ArgumentOutOfRangeException($"{idx} in a collection of  ${tensor.numel()} elements.");
			}
			if (tensor.is_contiguous() || idx == 0L)
			{
				return idx;
			}
			long num = 0L;
			long[] shape = tensor.shape;
			long[] array = tensor.stride();
			for (int num2 = shape.Length - 1; num2 >= 0; num2--)
			{
				idx = Math.DivRem(idx, shape[num2], out var result);
				num += result * array[num2];
			}
			return num;
		}

		private static long TranslateIndex(long[] idx, torch.Tensor tensor)
		{
			long num = 0L;
			long[] shape = tensor.shape;
			long[] array = tensor.stride();
			for (int num2 = shape.Length - 1; num2 >= 0; num2--)
			{
				if (idx[num2] >= shape[num2] || idx[num2] < 0)
				{
					throw new IndexOutOfRangeException($"{idx[num2]} >= {shape[num2]} in dimension {num2}.");
				}
				num += idx[num2] * array[num2];
			}
			return num;
		}

		internal unsafe static T ReadItemAt(torch.Tensor tensor, long index)
		{
			if (tensor.device_type != DeviceType.CPU)
			{
				throw new InvalidOperationException("Reading data from non-CPU memory is not supported. Move or copy the tensor to the cpu before reading.");
			}
			tensor.ValidateType(typeof(T));
			long[] array = tensor.stride();
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] < 0)
				{
					throw new NotImplementedException($"Negative tensor strides are not currently supported. tensor.strides({i}) == {array[i]}");
				}
			}
			IntPtr intPtr = NativeMethods.THSTensor_data(tensor.Handle);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			T* ptr = (T*)(void*)intPtr;
			return ptr[TranslateIndex(index, tensor)];
		}

		public static bool operator ==(TensorAccessor<T> left, TensorAccessor<T> right)
		{
			if (left.Count != right.Count)
			{
				return false;
			}
			IEnumerator<T> enumerator = left.GetEnumerator();
			IEnumerator<T> enumerator2 = right.GetEnumerator();
			while (enumerator.MoveNext() && enumerator2.MoveNext())
			{
				if (!enumerator.Current.Equals(enumerator2.Current))
				{
					return false;
				}
			}
			return true;
		}

		public static bool operator !=(TensorAccessor<T> left, TensorAccessor<T> right)
		{
			return !(left == right);
		}

		private IEnumerable<long> GetSubsequentIndices(long startingIndex)
		{
			if (startingIndex < 0 || startingIndex >= Count)
			{
				throw new ArgumentOutOfRangeException("startingIndex");
			}
			if (Count <= 1)
			{
				if (Count == 0L)
				{
					return Enumerable.Empty<long>();
				}
				return new long[1].AsEnumerable();
			}
			if (_tensor.is_contiguous())
			{
				return ContiguousIndices(startingIndex);
			}
			long[] array = _tensor.stride();
			if (array.Length == 1)
			{
				return SimpleIndices(startingIndex, array[0]);
			}
			return MultiDimensionIndices(startingIndex);
		}

		private IEnumerable<long> MultiDimensionIndices(long startingIndex)
		{
			long[] shape = _tensor.shape;
			long[] stride = _tensor.stride();
			long[] inds = new long[stride.Length];
			long index = startingIndex;
			long offset = TranslateIndex(startingIndex, _tensor);
			while (true)
			{
				index++;
				yield return offset;
				if (index >= Count)
				{
					break;
				}
				int num = inds.Length - 1;
				while (true)
				{
					offset += stride[num];
					if (++inds[num] < shape[num])
					{
						break;
					}
					offset -= inds[num] * stride[num];
					inds[num] = 0L;
					num--;
				}
			}
		}

		private IEnumerable<long> SimpleIndices(long startingIndex, long stride)
		{
			long index = startingIndex;
			long offset = TranslateIndex(startingIndex, _tensor);
			for (; index < Count; index++)
			{
				yield return offset;
				offset += stride;
			}
		}

		private IEnumerable<long> ContiguousIndices(long startingIndex)
		{
			for (long index = startingIndex; index < Count; index++)
			{
				yield return index;
			}
		}

		public override bool Equals(object obj)
		{
			TensorAccessor<T> tensorAccessor = obj as TensorAccessor<T>;
			if (tensorAccessor == null)
			{
				return false;
			}
			if (_tensor_data_ptr == tensorAccessor._tensor_data_ptr)
			{
				return true;
			}
			if (Count != tensorAccessor.Count)
			{
				return false;
			}
			for (long num = 0L; num < Count; num++)
			{
				if (!this[new long[1] { num }].Equals(tensorAccessor[new long[1] { num }]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		private void Dispose(bool disposing)
		{
			_tensor_data_ptr = IntPtr.Zero;
			_tensor = null;
		}

		public IEnumerator<T> GetEnumerator()
		{
			if (Count <= 1)
			{
				if (Count == 0L)
				{
					return Enumerable.Empty<T>().GetEnumerator();
				}
				return new T[1] { this[new long[1]] }.AsEnumerable().GetEnumerator();
			}
			if (_tensor.is_contiguous())
			{
				return new SimpleAtorImpl(this, 1L);
			}
			long[] array = _tensor.stride();
			if (array.Length == 1)
			{
				return new SimpleAtorImpl(this, array[0]);
			}
			return new GeneralAtorImpl(this, array);
		}
	}
}
namespace TorchSharp.Utils.tensorboard.Enums
{
	public enum HistogramBinSelector : byte
	{
		Doane,
		Rice,
		Scott,
		Sqrt,
		Stone,
		Sturges,
		Tensorflow
	}
}
namespace TorchSharp.PInvoke
{
	[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
	internal delegate void GCHandleDeleter(IntPtr memory);
	internal static class NativeMethods
	{
		internal struct ArrayWithSize
		{
			public IntPtr Array;

			public long Size;
		}

		internal struct NodeUnmanagedPtr
		{
			public IntPtr sharedPtr;

			public IntPtr weakPtr;
		}

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate ArrayWithSize ApplyFunc([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] IntPtr[] array, int size);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		internal delegate void ManagedDeleteNode();

		[DllImport("LibTorchSharp")]
		internal static extern uint crc32c_append(uint crc, IntPtr value, ulong length);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSAutograd_isGradEnabled();

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_setGrad([MarshalAs(UnmanagedType.U1)] bool enabled);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSAutograd_isInferenceModeEnabled();

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSAutograd_getInferenceModeGuard([MarshalAs(UnmanagedType.U1)] bool mode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_deleteInferenceModeGuard(IntPtr guard);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSAutograd_isAnomalyEnabled();

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSAutograd_shouldCheckNaN();

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_setAnomaly([MarshalAs(UnmanagedType.U1)] bool enabled, [MarshalAs(UnmanagedType.U1)] bool check_nan);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_grad(IntPtr outputs, long oLength, IntPtr inputs, long iLength, IntPtr grad_outs, long gLength, [MarshalAs(UnmanagedType.U1)] bool retain_graph, [MarshalAs(UnmanagedType.U1)] bool create_graph, [MarshalAs(UnmanagedType.U1)] bool allow_unused, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_backward(IntPtr tensors, long tLength, IntPtr grad_tensors, long gtLength, [MarshalAs(UnmanagedType.U1)] bool retain_graph, [MarshalAs(UnmanagedType.U1)] bool create_graph, IntPtr inputs, long iLength);

		[DllImport("LibTorchSharp")]
		internal static extern NodeUnmanagedPtr THSAutograd_CSharpNode_ctor(ApplyFunc applyFunc, ManagedDeleteNode managedDeleteNode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_CSharpNode_disposeSharedPtr(NodeUnmanagedPtr node);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_CSharpNode_disposeWeakPtr(NodeUnmanagedPtr node);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_CSharpNode_setNextEdges(NodeUnmanagedPtr node, ArrayWithSize vars, [MarshalAs(UnmanagedType.U1)] bool is_executable);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_CSharpNode_clearInputMetadata(NodeUnmanagedPtr node);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_Function_wrapOutputs(ArrayWithSize vars, ArrayWithSize nonDiff, ArrayWithSize dirty, ArrayWithSize outputs, NodeUnmanagedPtr node, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSAutograd_SavedVariable_ctor(IntPtr variable, NodeUnmanagedPtr nodeRef, [MarshalAs(UnmanagedType.U1)] bool is_inplace_on_view);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_SavedVariable_dispose(IntPtr saved_variable);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSAutograd_SavedVariable_unpack(IntPtr saved_variable, NodeUnmanagedPtr node_saved_for);

		[DllImport("LibTorchSharp")]
		internal static extern void THSAutograd_SavedVariable_reset_data(IntPtr saved_variable);

		[DllImport("LibTorchSharp")]
		internal static extern void THSCuda_manual_seed(long seed);

		[DllImport("LibTorchSharp")]
		internal static extern void THSCuda_manual_seed_all(long seed);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSBackend_cublas_get_allow_tf32();

		[DllImport("LibTorchSharp")]
		internal static extern void THSBackend_cublas_set_allow_tf32([MarshalAs(UnmanagedType.U1)] bool flag);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSBackend_cudnn_get_allow_tf32();

		[DllImport("LibTorchSharp")]
		internal static extern void THSBackend_cudnn_set_allow_tf32([MarshalAs(UnmanagedType.U1)] bool flag);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSBackend_cuda_get_allow_fp16_reduced_precision_reduction();

		[DllImport("LibTorchSharp")]
		internal static extern void THSBackend_cuda_set_allow_fp16_reduced_precision_reduction([MarshalAs(UnmanagedType.U1)] bool flag);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSBackend_cuda_get_enable_flash_sdp();

		[DllImport("LibTorchSharp")]
		internal static extern void THSBackend_cuda_set_enable_flash_sdp([MarshalAs(UnmanagedType.U1)] bool flag);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSBackend_cuda_get_enable_math_sdp();

		[DllImport("LibTorchSharp")]
		internal static extern void THSBackend_cuda_set_enable_math_sdp([MarshalAs(UnmanagedType.U1)] bool flag);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSData_loaderMNIST([MarshalAs(UnmanagedType.LPStr)] string filename, long batchSize, [MarshalAs(UnmanagedType.U1)] bool isTrain);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSData_loaderCIFAR10([MarshalAs(UnmanagedType.LPStr)] string path, long batchSize, [MarshalAs(UnmanagedType.U1)] bool isTrain);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSData_current(IntPtr iterator, IntPtr data, IntPtr target);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSData_moveNext(IntPtr iterator);

		[DllImport("LibTorchSharp")]
		internal static extern long THSData_size(IntPtr iterator);

		[DllImport("LibTorchSharp")]
		internal static extern void THSData_reset(IntPtr iterator);

		[DllImport("LibTorchSharp")]
		internal static extern void THSData_dispose(IntPtr iterator);

		[DllImport("LibTorchSharp")]
		internal static extern long THSGenerator_initial_seed(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSGenerator_get_rng_state(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSGenerator_set_rng_state(IntPtr handle, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSGenerator_gen_manual_seed(IntPtr handle, long seed);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSGenerator_new(ulong seed, long device_type, long device_index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSGenerator_default_generator();

		[DllImport("LibTorchSharp")]
		internal static extern void THSGenerator_dispose(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSGenerator_manual_seed(long seed);

		[DllImport("LibTorchSharp")]
		internal static extern double THSInit_calculate_gain(long nonlinearity, double param);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_constant_(IntPtr tensor, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_dirac_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_eye_(IntPtr matrix);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_normal_(IntPtr tensor, double mean, double std);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_trunc_normal_(IntPtr tensor, double mean, double std, double a, double b);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_ones_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_orthogonal_(IntPtr tensor, double gain);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_sparse_(IntPtr tensor, double sparsity, double std);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_uniform_(IntPtr tensor, double low, double high);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_kaiming_normal_(IntPtr tensor, double a, long mode, long nonlinearity);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_kaiming_uniform_(IntPtr tensor, double a, long mode, long nonlinearity);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_xavier_normal_(IntPtr tensor, double gain);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_xavier_uniform_(IntPtr tensor, double gain);

		[DllImport("LibTorchSharp")]
		internal static extern void THSInit_zeros_(IntPtr tensor);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern void THSJIT_CompilationUnit_Invoke(IntPtr module, string name, IntPtr tensors, int length, AllocateIndexedNativeTensorOrScalarArray allocator, out sbyte typeCode, int idx);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_CompilationUnit_dispose(IntPtr handle);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSJIT_compile(string script);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_dispose(torch.nn.Module.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_named_parameters(torch.nn.Module.HType module, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_named_buffers(torch.nn.Module.HType module, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_named_attributes(torch.nn.Module.HType module, [MarshalAs(UnmanagedType.U1)] bool recurse, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_set_attribute(torch.nn.Module.HType module, [MarshalAs(UnmanagedType.LPStr)] string name, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_named_modules(torch.nn.Module.HType module, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_named_children(torch.nn.Module.HType module, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern int THSJIT_Module_num_inputs(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern int THSJIT_Module_num_outputs(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_train(torch.nn.Module.HType module, [MarshalAs(UnmanagedType.U1)] bool on);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_eval(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSJIT_Module_is_training(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_zero_grad(torch.nn.Module.HType module, [MarshalAs(UnmanagedType.U1)] bool set_to_none);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_to_device(torch.nn.Module.HType module, long deviceType, long deviceIndex);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_to_device_dtype(torch.nn.Module.HType module, sbyte dtype, long deviceType, long deviceIndex);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_to_dtype(torch.nn.Module.HType module, sbyte dtype);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSJIT_Module_getInputType(torch.nn.Module.HType module, int index);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Module_forward(torch.nn.Module.HType module, IntPtr tensors, int length, AllocateIndexedNativeTensorOrScalarArray allocator, out sbyte typeCode, int idx);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern void THSJIT_Module_invoke(torch.nn.Module.HType module, string name, IntPtr tensors, int length, AllocateIndexedNativeTensorOrScalarArray allocator, out sbyte typeCode, int idx);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSJIT_load(string filename, long deviceType, long deviceIndex);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSJIT_load_byte_array(IntPtr bytes, long size, long deviceType, long deviceIndex);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern void THSJIT_save(torch.nn.Module.HType handle, string filename);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_save_byte_array(torch.nn.Module.HType handle, IntPtr bytes, long size);

		[DllImport("LibTorchSharp")]
		internal static extern long THSJIT_TensorType_sizes(torch.jit.Type.HType handle, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern int THSJIT_getDimensionedTensorTypeDimensions(torch.jit.Type.HType handle);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern string THSJIT_getDimensionedTensorDevice(torch.jit.Type.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern sbyte THSJIT_TensorType_dtype(torch.jit.Type.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_Type_dispose(torch.jit.Type.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_TensorType_dispose(torch.jit.Type.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern sbyte THSJIT_Type_kind(torch.jit.Type.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSJIT_Type_cast(torch.jit.Type.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSJIT_AllocateTensorOrScalarArray(int size);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_FreeTensorOrScalarArray(IntPtr ptr);

		[DllImport("LibTorchSharp")]
		internal static extern void THSJIT_SetTensorOrScalar(IntPtr array, int index, long type_code, long array_index, IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSJIT_GetTensorOrScalar(IntPtr array, int index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_cholesky(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_cholesky_ex(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool check_errors, out IntPtr pInfo);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_cond_int(IntPtr tensor, int p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_cond_float(IntPtr tensor, double p);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSLinalg_cond_str(IntPtr tensor, [MarshalAs(UnmanagedType.LPStr)] string p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_cond_none(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_cross(IntPtr input, IntPtr other, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_det(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_slogdet(IntPtr tensor, out IntPtr pLogabsdet);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_eig(IntPtr tensor, out IntPtr pEigenvectors);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_geqrf(IntPtr tensor, out IntPtr tau);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_eigh(IntPtr tensor, byte UPLO, out IntPtr pEigenvectors);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_eigvals(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_eigvalsh(IntPtr tensor, byte UPLO);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_householder_product(IntPtr tensor, IntPtr tau);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_inv(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_inv_ex(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool check_errors, out IntPtr pInfo);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_lstsq_none(IntPtr tensor, IntPtr other, out IntPtr pResiduals, out IntPtr pRank, out IntPtr pSingularValues);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_lstsq_rcond(IntPtr tensor, IntPtr other, double rcond, out IntPtr pResiduals, out IntPtr pRank, out IntPtr pSingularValues);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_ldl_factor(IntPtr A, [MarshalAs(UnmanagedType.U1)] bool hermitian, out IntPtr pivots);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_ldl_factor_ex(IntPtr A, [MarshalAs(UnmanagedType.U1)] bool hermitian, [MarshalAs(UnmanagedType.U1)] bool check_errors, out IntPtr pivots, out IntPtr info);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_ldl_solve(IntPtr LD, IntPtr pivots, IntPtr B, [MarshalAs(UnmanagedType.U1)] bool hermitian);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_lu(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool pivot, out IntPtr pL, out IntPtr pU);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_lu_factor(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool pivot, out IntPtr pPivots);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_matrix_norm_fronuc(IntPtr tensor, byte fronuc, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_matrix_norm(IntPtr tensor, IntPtr ord, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_matrix_rank(IntPtr tensor, double atol, [MarshalAs(UnmanagedType.U1)] bool has_atol, double rtol, [MarshalAs(UnmanagedType.U1)] bool has_rtol, [MarshalAs(UnmanagedType.U1)] bool hermitian);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_matrix_rank_tensor(IntPtr tensor, IntPtr atol, IntPtr rtol, [MarshalAs(UnmanagedType.U1)] bool hermitian);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_dot(IntPtr tensor, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_multi_dot(IntPtr tensor, int len);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSLinalg_norm_str(IntPtr tensor, [MarshalAs(UnmanagedType.LPStr)] string p, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_norm_float(IntPtr tensor, double p, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_norm_int(IntPtr tensor, int p, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_norm_opt(IntPtr tensor, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_pinv(IntPtr tensor, double atol, [MarshalAs(UnmanagedType.U1)] bool has_atol, double rtol, [MarshalAs(UnmanagedType.U1)] bool has_rtol, [MarshalAs(UnmanagedType.U1)] bool hermitian);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_pinv_tensor(IntPtr tensor, IntPtr atol, IntPtr rtol, [MarshalAs(UnmanagedType.U1)] bool hermitian);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_qr(IntPtr tensor, byte mode, out IntPtr pR);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_solve(IntPtr tensor, IntPtr other, [MarshalAs(UnmanagedType.U1)] bool left);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_solve_ex(IntPtr tensor, IntPtr other, [MarshalAs(UnmanagedType.U1)] bool left, [MarshalAs(UnmanagedType.U1)] bool check_errors, out IntPtr infos);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_solve_triangular(IntPtr tensor, IntPtr other, [MarshalAs(UnmanagedType.U1)] bool upper, [MarshalAs(UnmanagedType.U1)] bool left, [MarshalAs(UnmanagedType.U1)] bool unitriangular);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_solve_triangular_out(IntPtr tensor, IntPtr other, [MarshalAs(UnmanagedType.U1)] bool upper, [MarshalAs(UnmanagedType.U1)] bool left, [MarshalAs(UnmanagedType.U1)] bool unitriangular, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_svd(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool fullMatrices, out IntPtr pS, out IntPtr pVh);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_svdvals(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_tensorinv(IntPtr tensor, long ind);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_tensorsolve(IntPtr tensor, IntPtr other, IntPtr dim, int dim_length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_vector_norm(IntPtr tensor, IntPtr ord, IntPtr dim, int dim_length, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_matrix_power(IntPtr tensor, long n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_pinverse(IntPtr tensor, double rcond, [MarshalAs(UnmanagedType.U1)] bool hermitian);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_vander(IntPtr tensor, long N);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_vecdot(IntPtr x, IntPtr y, long dim, IntPtr output);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_lu_solve(IntPtr B, IntPtr LU, IntPtr pivots, [MarshalAs(UnmanagedType.U1)] bool left, [MarshalAs(UnmanagedType.U1)] bool adjoint, IntPtr output);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSLinalg_tensordot(IntPtr input1, IntPtr input2, IntPtr dims1, int dims1_length, IntPtr dims2, int dims2_length);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern void THSNN_Module_save(torch.nn.Module.HType handle, [MarshalAs(UnmanagedType.LPStr)] string location);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		[return: MarshalAs(UnmanagedType.LPStr)]
		internal static extern string THSNN_Module_name(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSNN_custom_module([MarshalAs(UnmanagedType.LPStr)] string name, ForwardFunctionC forward, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern torch.nn.utils.rnn.PackedSequence.HType THSNN_RNN_forward_with_packed_input(torch.nn.Module.HType module, torch.nn.utils.rnn.PackedSequence.HType input, IntPtr h_0, out IntPtr h_n);

		[DllImport("LibTorchSharp")]
		internal static extern torch.nn.utils.rnn.PackedSequence.HType THSNN_pack_padded_sequence(IntPtr input, IntPtr lengths, [MarshalAs(UnmanagedType.U1)] bool batch_first, [MarshalAs(UnmanagedType.U1)] bool enforce_sorted);

		[DllImport("LibTorchSharp")]
		internal static extern torch.nn.utils.rnn.PackedSequence.HType THSNN_pack_sequence(IntPtr[] sequences, int sequences_len, [MarshalAs(UnmanagedType.U1)] bool enforce_sorted);

		[DllImport("LibTorchSharp")]
		internal static extern torch.nn.utils.rnn.PackedSequence.HType THSNN_LSTM_forward_with_packed_input(torch.nn.Module.HType module, torch.nn.utils.rnn.PackedSequence.HType input, IntPtr h_0, IntPtr c_0, out IntPtr h_n, out IntPtr c_n);

		[DllImport("LibTorchSharp")]
		internal static extern torch.nn.utils.rnn.PackedSequence.HType THSNN_GRU_forward_with_packed_input(torch.nn.Module.HType module, torch.nn.utils.rnn.PackedSequence.HType input, IntPtr h_0, out IntPtr h_n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_interpolate(IntPtr input, IntPtr size, int size_len, IntPtr scale_factor, int scale_factor_len, byte mode, byte align_corners, [MarshalAs(UnmanagedType.U1)] bool recompute_scale_factor, [MarshalAs(UnmanagedType.U1)] bool antialias);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_grid_sample(IntPtr input, IntPtr grid, byte mode, byte padding_mode, byte align_corners);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_alpha_dropout(IntPtr input, double p, [MarshalAs(UnmanagedType.U1)] bool training, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_functional_bilinear(IntPtr input1, IntPtr input2, IntPtr weights, IntPtr bias);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_cosine_similarity(IntPtr input1, IntPtr input2, long dim, double eps);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_dropout(IntPtr input, double p, [MarshalAs(UnmanagedType.U1)] bool training, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_dropout2d(IntPtr input, double p, [MarshalAs(UnmanagedType.U1)] bool training, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Embedding_forward(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Embedding_weight(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Embedding_set_weight(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Embedding_ctor(long num_embeddings, long embedding_dims, long padding_idx, [MarshalAs(UnmanagedType.U1)] bool hasPI, double max_norm, [MarshalAs(UnmanagedType.U1)] bool hasMN, double norm_type, [MarshalAs(UnmanagedType.U1)] bool scale_grad_by_freq, [MarshalAs(UnmanagedType.U1)] bool sparse, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Embedding_from_pretrained(IntPtr embeddings, [MarshalAs(UnmanagedType.U1)] bool freeze, long padding_idx, [MarshalAs(UnmanagedType.U1)] bool hasPI, double max_norm, [MarshalAs(UnmanagedType.U1)] bool hasMN, double norm_type, [MarshalAs(UnmanagedType.U1)] bool scale_grad_by_freq, [MarshalAs(UnmanagedType.U1)] bool sparse, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_dropout3d(IntPtr input, double p, [MarshalAs(UnmanagedType.U1)] bool training, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_EmbeddingBag_forward(torch.nn.Module.HType module, IntPtr tensor, IntPtr offsets, IntPtr per_sample_weights);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_EmbeddingBag_weight(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_EmbeddingBag_set_weight(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_EmbeddingBag_ctor(long num_embeddings, long embedding_dims, double max_norm, [MarshalAs(UnmanagedType.U1)] bool hasMN, double norm_type, [MarshalAs(UnmanagedType.U1)] bool scale_grad_by_freq, long mode, [MarshalAs(UnmanagedType.U1)] bool sparse, [MarshalAs(UnmanagedType.U1)] bool include_last_offset, long padding_idx, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_EmbeddingBag_from_pretrained(IntPtr embeddings, [MarshalAs(UnmanagedType.U1)] bool freeze, double max_norm, [MarshalAs(UnmanagedType.U1)] bool hasMN, double norm_type, [MarshalAs(UnmanagedType.U1)] bool scale_grad_by_freq, long mode, [MarshalAs(UnmanagedType.U1)] bool sparse, [MarshalAs(UnmanagedType.U1)] bool include_last_offset, long padding_idx, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_feature_alpha_dropout(IntPtr input, double p, [MarshalAs(UnmanagedType.U1)] bool training, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_fold(IntPtr input, long out1, long out2, long kernel1, long kernel2, long stride1, long stride, long pad1, long pad2, long dil1, long dil2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_unfold(IntPtr input, long kernel1, long kernel2, long stride1, long stride, long pad1, long pad2, long dil1, long dil2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_cross_entropy(IntPtr srct, IntPtr trgt, IntPtr wgt, long ignore_index, [MarshalAs(UnmanagedType.U1)] bool hasII, long reduction, double smooting);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_binary_cross_entropy(IntPtr srct, IntPtr trgt, IntPtr wgt, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_binary_cross_entropy_with_logits(IntPtr srct, IntPtr trgt, IntPtr wgt, long reduction, IntPtr posWeights);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_cosine_embedding_loss(IntPtr input1, IntPtr input2, IntPtr trgt, double margin, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_ctc_loss(IntPtr log_probs, IntPtr targets, IntPtr input_lengths, IntPtr target_lengths, long blank, [MarshalAs(UnmanagedType.U1)] bool zero_infinity, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_hinge_embedding_loss(IntPtr input, IntPtr trgt, double margin, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_huber_loss(IntPtr input, IntPtr trgt, double delta, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_margin_ranking_loss(IntPtr input1, IntPtr input2, IntPtr target, double margin, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_multilabel_margin_loss(IntPtr input, IntPtr target, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_multilabel_soft_margin_loss(IntPtr input, IntPtr target, IntPtr weight, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_multi_margin_loss(IntPtr input, IntPtr target, long p, double margin, IntPtr weight, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_mse_loss(IntPtr srct, IntPtr trgt, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_l1_loss(IntPtr srct, IntPtr trgt, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_nll_loss(IntPtr srct, IntPtr trgt, IntPtr wgt, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_poisson_loss(IntPtr srct, IntPtr trgt, [MarshalAs(UnmanagedType.U1)] bool logInput, [MarshalAs(UnmanagedType.U1)] bool full, float eps, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_kl_div_loss(IntPtr input, IntPtr target, long reduction, [MarshalAs(UnmanagedType.U1)] bool logTarget);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_smooth_l1_loss(IntPtr srct, IntPtr trgt, long reduction, double beta);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_soft_margin_loss(IntPtr srct, IntPtr trgt, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_triplet_margin_loss(IntPtr anchor, IntPtr positive, IntPtr negative, double margin, long p, double eps, [MarshalAs(UnmanagedType.U1)] bool swap, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_triplet_margin_with_distance_loss(IntPtr anchor, IntPtr positive, IntPtr negative, DistanceFunctionNative? distance_function, double margin, [MarshalAs(UnmanagedType.U1)] bool swap, long reduction);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Optimizer_dispose(torch.optim.Optimizer.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Optimizer_zero_grad(torch.optim.Optimizer.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Optimizer_step(torch.optim.Optimizer.HType module, torch.optim.Optimizer.LossClosure closure);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Optimizer_getParameters(torch.optim.Optimizer.HType module, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_dispose(torch.nn.Module.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_to_device_dtype(torch.nn.Module.HType module, sbyte dtype, long deviceType, long deviceIndex, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_to_device(torch.nn.Module.HType module, long deviceType, long deviceIndex, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_to_dtype(torch.nn.Module.HType module, sbyte dtype, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSNN_Module_load([MarshalAs(UnmanagedType.LPStr)] string location);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_train(torch.nn.Module.HType module, [MarshalAs(UnmanagedType.U1)] bool on);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSNN_Module_is_training(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_zero_grad(torch.nn.Module.HType module, [MarshalAs(UnmanagedType.U1)] bool set_to_none);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_get_named_parameters(torch.nn.Module.HType module, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_get_named_buffers(torch.nn.Module.HType module, AllocatePinnedArray allocator1, AllocatePinnedArray allocator2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_Module_get_parameters(torch.nn.Module.HType module, AllocatePinnedArray allocator, [MarshalAs(UnmanagedType.U1)] bool recurse);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_AnyModule_dispose(torch.nn.BoxedModule.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNN_forward(torch.nn.Module.HType module, IntPtr input, IntPtr h_0, out IntPtr h_n);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNN_flatten_parameters(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNN_bias_ih(torch.nn.Module.HType module, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNN_bias_hh(torch.nn.Module.HType module, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNN_set_bias_ih(torch.nn.Module.HType module, IntPtr tensor, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNN_set_bias_hh(torch.nn.Module.HType module, IntPtr tensor, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNN_weight_ih(torch.nn.Module.HType module, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNN_weight_hh(torch.nn.Module.HType module, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNN_set_weight_ih(torch.nn.Module.HType module, IntPtr tensor, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNN_set_weight_hh(torch.nn.Module.HType module, IntPtr tensor, long idx);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNN_ctor(long input_size, long hidden_size, long num_layers, long nonlinearity, [MarshalAs(UnmanagedType.U1)] bool bias, [MarshalAs(UnmanagedType.U1)] bool batchFirst, double dropout, [MarshalAs(UnmanagedType.U1)] bool bidirectional, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNNCell_forward(torch.nn.Module.HType module, IntPtr input, IntPtr h_0);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNNCell_bias_ih(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNNCell_set_bias_ih(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNNCell_bias_hh(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNNCell_set_bias_hh(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNNCell_weight_ih(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNNCell_set_weight_ih(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNNCell_weight_hh(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_RNNCell_set_weight_hh(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_RNNCell_ctor(long input_size, long hidden_size, long nonlinearity, [MarshalAs(UnmanagedType.U1)] bool bias, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_functional_linear(IntPtr input, IntPtr weights, IntPtr bias);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTMCell_forward(torch.nn.Module.HType module, IntPtr input, IntPtr h_0, IntPtr c_0, out IntPtr c_n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTMCell_bias_ih(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_LSTMCell_set_bias_ih(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTMCell_bias_hh(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_LSTMCell_set_bias_hh(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTMCell_weight_ih(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_LSTMCell_set_weight_ih(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTMCell_weight_hh(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_LSTMCell_set_weight_hh(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTMCell_ctor(long input_size, long hidden_size, [MarshalAs(UnmanagedType.U1)] bool bias, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_PackedSequence_dispose(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_PackedSequence_data(torch.nn.utils.rnn.PackedSequence.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_PackedSequence_batch_sizes(torch.nn.utils.rnn.PackedSequence.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_PackedSequence_sorted_indices(torch.nn.utils.rnn.PackedSequence.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_PackedSequence_unsorted_indices(torch.nn.utils.rnn.PackedSequence.HType handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_pad_packed_sequence(torch.nn.utils.rnn.PackedSequence.HType sequence, [MarshalAs(UnmanagedType.U1)] bool batch_first, double padding_value, long total_length, out IntPtr res1, out IntPtr res2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_pad_sequence(IntPtr[] sequences, int sequences_len, [MarshalAs(UnmanagedType.U1)] bool batch_first, double padding_value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_MultiheadAttention_forward(torch.nn.Module.HType module, IntPtr query, IntPtr key, IntPtr value, IntPtr key_padding_mask, [MarshalAs(UnmanagedType.U1)] bool need_weights, IntPtr attn_mask, out IntPtr res1, out IntPtr res2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_MultiheadAttention_ctor(long embeded_dim, long num_heads, double dropout, [MarshalAs(UnmanagedType.U1)] bool bias, [MarshalAs(UnmanagedType.U1)] bool add_bias_kv, [MarshalAs(UnmanagedType.U1)] bool add_zero_attn, long kdim, long vdim, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_one_hot(IntPtr self, long num_classes);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_pairwise_distance(IntPtr input1, IntPtr input2, double p, double eps, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_pixel_unshuffle(IntPtr tensor, long downscale_factor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_pixel_shuffle(IntPtr tensor, long upscale_factor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRUCell_forward(torch.nn.Module.HType module, IntPtr input, IntPtr h_0);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRUCell_bias_ih(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_GRUCell_set_bias_ih(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRUCell_bias_hh(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_GRUCell_set_bias_hh(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRUCell_weight_ih(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_GRUCell_set_weight_ih(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRUCell_weight_hh(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_GRUCell_set_weight_hh(torch.nn.Module.HType module, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRUCell_ctor(long input_size, long hidden_size, [MarshalAs(UnmanagedType.U1)] bool bias, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTM_forward(torch.nn.Module.HType module, IntPtr input, IntPtr h_0, IntPtr c_0, out IntPtr h_n, out IntPtr c_n);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_LSTM_flatten_parameters(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LSTM_ctor(long input_size, long hidden_size, long num_layers, [MarshalAs(UnmanagedType.U1)] bool bias, [MarshalAs(UnmanagedType.U1)] bool batchFirst, double dropout, [MarshalAs(UnmanagedType.U1)] bool bidirectional, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_GRU_flatten_parameters(torch.nn.Module.HType module);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRU_ctor(long input_size, long hidden_size, long num_layers, [MarshalAs(UnmanagedType.U1)] bool bias, [MarshalAs(UnmanagedType.U1)] bool batchFirst, double dropout, [MarshalAs(UnmanagedType.U1)] bool bidirectional, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_GRU_forward(torch.nn.Module.HType module, IntPtr input, IntPtr h_0, out IntPtr h_n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_LBFGS_ctor(IntPtr parameters, int len, double learningRate, long max_iter, long max_eval, double tolerange_grad, double tolerance_change, long history_size);

		[DllImport("LibTorchSharp")]
		internal static extern void THSNN_LBFGS_set_lr(torch.optim.Optimizer.HType optimizer, double lr);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Sequential_ctor();

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Transformer_forward(torch.nn.Module.HType module, IntPtr src, IntPtr tgt, IntPtr src_mask, IntPtr tgt_mask, IntPtr memory_mask, IntPtr src_key_padding_mask, IntPtr tgt_key_padding_mask, IntPtr memory_key_padding_mask);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_Transformer_ctor(long d_model, long nhead, long num_encoder_layers, long num_decoder_layers, long dim_feedforward, double dropout, long activation, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerDecoder_forward(torch.nn.Module.HType module, IntPtr tgt, IntPtr memory, IntPtr tgt_mask, IntPtr memory_mask, IntPtr tgt_key_padding_mask, IntPtr memory_key_padding_mask);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerDecoder_ctor(torch.nn.Module.HType decoder_layer, long num_layers, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerDecoderLayer_forward(torch.nn.Module.HType module, IntPtr tgt, IntPtr memory, IntPtr tgt_mask, IntPtr memory_mask, IntPtr tgt_key_padding_mask, IntPtr memory_key_padding_mask);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerDecoderLayer_ctor(long d_model, long nhead, long dim_feedforward, double dropout, long activation, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerEncoderLayer_forward(torch.nn.Module.HType module, IntPtr src, IntPtr src_mask, IntPtr src_key_padding_mask);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerEncoderLayer_ctor(long d_model, long nhead, long dim_feedforward, double dropout, long activation, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerEncoder_ctor(torch.nn.Module.HType encoder_layer, long num_layers, out IntPtr pBoxedModule);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_TransformerEncoder_forward(torch.nn.Module.HType module, IntPtr src, IntPtr src_mask, IntPtr src_key_padding_mask);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_pad(IntPtr input, IntPtr pad, int pad_length, byte mode, double value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_affine_grid(IntPtr theta, IntPtr size, int size_len, [MarshalAs(UnmanagedType.U1)] bool align_corners);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_normalize(IntPtr input, double p, long dim, double eps);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_batch_norm(IntPtr input, IntPtr running_mean, IntPtr running_var, IntPtr weight, IntPtr bias, [MarshalAs(UnmanagedType.U1)] bool training, double momentum, double eps);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_group_norm(IntPtr input, long num_groups, IntPtr weight, IntPtr bias, double eps);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_instance_norm(IntPtr input, IntPtr running_mean, IntPtr running_var, IntPtr weight, IntPtr bias, [MarshalAs(UnmanagedType.U1)] bool use_input_stats, double momentum, double eps);

		[DllImport("LibTorchSharp")]
		internal unsafe static extern IntPtr THSNN_layer_norm(IntPtr input, long* normalized_shape, long normalized_shape_len, IntPtr weight, IntPtr bias, double eps);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_local_response_norm(IntPtr input, long size, double alpha, double beta, double k);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSNN_scaled_dot_product_attention(IntPtr query, IntPtr key, IntPtr value, IntPtr attention_mask, double p, [MarshalAs(UnmanagedType.U1)] bool casual);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_airy_ai(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_airy_ai_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_j0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_j0_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_j1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_j1_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_y0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_y0_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_y1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_bessel_y1_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_i0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_i0_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_i1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_i1_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_k0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_k0_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_k1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_modified_bessel_k1_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_scaled_modified_bessel_k0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_scaled_modified_bessel_k0_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_scaled_modified_bessel_k1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_scaled_modified_bessel_k1_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_spherical_bessel_j0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_spherical_bessel_j0_out(IntPtr tensor, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_t(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_t_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_u(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_u_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_v(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_v_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_w(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_chebyshev_polynomial_w_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_t(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_t_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_u(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_u_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_v(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_v_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_w(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_shifted_chebyshev_polynomial_w_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_hermite_polynomial_h(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_hermite_polynomial_h_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_hermite_polynomial_he(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_hermite_polynomial_he_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_laguerre_polynomial_l(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_laguerre_polynomial_l_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_legendre_polynomial_p(IntPtr x, IntPtr n);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_legendre_polynomial_p_out(IntPtr x, IntPtr n, IntPtr @out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_entr(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_erf(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_erfc(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_erfcx(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_erfinv(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_expit(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_expm1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_exp2(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_gammaln(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_gammainc(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_gammaincc(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_polygamma(long n, IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_multigammaln(IntPtr tensor, long p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_digamma(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_i0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_i0e(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_i1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_i1e(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_logit(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_log_softmax(IntPtr tensor, long dim, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_softmax(IntPtr tensor, long dim, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_ndtr(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_ndtri(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_sinc(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_xlog1py(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSSpecial_zeta(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern double THSSpecial_erf_scalar(double x);

		[DllImport("LibTorchSharp")]
		internal static extern double THSSpecial_erfc_scalar(double x);

		[DllImport("LibTorchSharp")]
		internal static extern ulong THSStorage_nbytes(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSStorage_set_nbytes(IntPtr tensor, ulong nbytes);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSStorage_data_ptr(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_where_list(IntPtr condition, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_squeeze_(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_squeeze_no_dim_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv1d(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv2d(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv3d(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv1d_padding(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, int padding, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv2d_padding(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, int padding, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv3d_padding(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, int padding, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv_transpose1d(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr outputPadding, int outputPaddingLength, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv_transpose2d(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr outputPadding, int outputPaddingLength, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conv_transpose3d(IntPtr input, IntPtr weight, IntPtr bias, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr outputPadding, int outputPaddingLength, IntPtr dilation, int dilationLength, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_pool1d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_max_pool1d_with_indices(IntPtr input, AllocatePinnedArray allocator, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_pool2d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_max_pool2d_with_indices(IntPtr input, AllocatePinnedArray allocator, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_pool3d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_max_pool3d_with_indices(IntPtr input, AllocatePinnedArray allocator, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, IntPtr dilation, int dilationLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_unpool1d(IntPtr tensor, IntPtr indices, IntPtr kernelSize, int kernelSizeLength, IntPtr outputSize, int outputSizeLength, IntPtr padding, int paddingLength, IntPtr strides, int stridesLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_unpool2d(IntPtr tensor, IntPtr indices, IntPtr kernelSize, int kernelSizeLength, IntPtr outputSize, int outputSizeLength, IntPtr padding, int paddingLength, IntPtr strides, int stridesLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_unpool3d(IntPtr tensor, IntPtr indices, IntPtr kernelSize, int kernelSizeLength, IntPtr outputSize, int outputSizeLength, IntPtr padding, int paddingLength, IntPtr strides, int stridesLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_avg_pool1d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode, [MarshalAs(UnmanagedType.U1)] bool count_include_pad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_avg_pool2d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode, [MarshalAs(UnmanagedType.U1)] bool count_include_pad, long divisor_override);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_avg_pool3d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode, [MarshalAs(UnmanagedType.U1)] bool count_include_pad, long divisor_override);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_avg_pool2d_backward(IntPtr gradOutput, IntPtr originalInput, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode, [MarshalAs(UnmanagedType.U1)] bool count_include_pad, long divisorOverride);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_avg_pool3d_backward(IntPtr gradOutput, IntPtr originalInput, IntPtr kernelSize, int kernelSizeLength, IntPtr strides, int stridesLength, IntPtr padding, int paddingLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode, [MarshalAs(UnmanagedType.U1)] bool count_include_pad, long divisorOverride);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_upsample_nearest1d(IntPtr input, IntPtr outputSize, int outputSizeLength, IntPtr scaleFactors, int scaleFactorsLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_upsample_nearest1d_backward(IntPtr grad_output, IntPtr outputSize, int outputSizeLength, IntPtr inputSize, int inputSizeLength, IntPtr scaleFactors, int scaleFactorsLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_upsample_nearest2d(IntPtr input, IntPtr outputSize, int outputSizeLength, IntPtr scaleFactors, int scaleFactorsLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_upsample_nearest2d_backward(IntPtr grad_output, IntPtr outputSize, int outputSizeLength, IntPtr inputSize, int inputSizeLength, IntPtr scaleFactors, int scaleFactorsLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_upsample_nearest3d_backward(IntPtr grad_output, IntPtr outputSize, int outputSizeLength, IntPtr inputSize, int inputSizeLength, IntPtr scaleFactors, int scaleFactorsLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_upsample_nearest3d(IntPtr input, IntPtr outputSize, int outputSizeLength, IntPtr scaleFactors, int scaleFactorsLength);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_dispose(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_free(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_ndimension(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_element_size(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_numel(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_is_leaf(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_alias(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_storage_offset(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_data(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_real(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_imag(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern float THSTensor_data_idx_float16(IntPtr handle, long i);

		[DllImport("LibTorchSharp")]
		internal static extern float THSTensor_data_idx_bfloat16(IntPtr handle, long i);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_item(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_fill_(IntPtr handle, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern sbyte THSTensor_type(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTensor_device_index(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTensor_device_type(IntPtr handle);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTensor_is_sparse(IntPtr handle);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSTensor_load([MarshalAs(UnmanagedType.LPStr)] string location);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSTensor_save(IntPtr tensor, [MarshalAs(UnmanagedType.LPStr)] string location);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTensor_requires_grad(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set_requires_grad(IntPtr handle, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_retain_grad(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTensor_result_type(IntPtr tensor1, IntPtr tensor2);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTensor_is_cpu(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cpu(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cuda(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_to_device(IntPtr handle, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool copy, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_to_type(IntPtr handle, sbyte scalar_type, [MarshalAs(UnmanagedType.U1)] bool copy, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_to_type_and_device(IntPtr handle, sbyte scalar_type, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool copy, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set_(IntPtr tensor, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_size(IntPtr handle, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_sizes(IntPtr handle, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTensor_has_names(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_names(IntPtr handle, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rename(IntPtr tensor, IntPtr names, long nLength);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_rename_(IntPtr tensor, IntPtr names, long nLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_refine_names(IntPtr tensor, IntPtr names, long nLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_indices(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_values(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_vander(IntPtr handle, long N, [MarshalAs(UnmanagedType.U1)] bool increasing);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_stride(IntPtr handle, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_strides(IntPtr handle, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_as_strided(IntPtr input, IntPtr psizes, int sz_length, IntPtr pstrides, int str_length, long storageOffset);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_backward(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_to_dense(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_clone(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_combinations(IntPtr handle, int r, [MarshalAs(UnmanagedType.U1)] bool with_replacement);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_copy_(IntPtr handle, IntPtr source, [MarshalAs(UnmanagedType.U1)] bool non_blocking);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTensor_is_contiguous(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_contiguous(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_is_pinned(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_pin_memory(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_grad(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set_grad(IntPtr handle, IntPtr grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_index(IntPtr tensor, IntPtr indexStarts, IntPtr indexEnds, IntPtr indexSteps, IntPtr indexTensors, int indicesLength);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_index_put_scalar_(IntPtr tensor, IntPtr indexStarts, IntPtr indexEnds, IntPtr indexSteps, IntPtr indexTensors, int indicesLength, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_index_put_(IntPtr tensor, IntPtr indexStarts, IntPtr indexEnds, IntPtr indexSteps, IntPtr indexTensors, int indicesLength, IntPtr value, [MarshalAs(UnmanagedType.U1)] bool accumulate);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_get1(IntPtr handle, long i1);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set1(IntPtr handle, long i1, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_get2(IntPtr handle, long i1, long i2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set2(IntPtr handle, long i1, long i2, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_get3(IntPtr handle, long i1, long i2, long i3);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set3(IntPtr handle, long i1, long i2, long i3, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_get4(IntPtr handle, long i1, long i2, long i3, long i4);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set4(IntPtr handle, long i1, long i2, long i3, long i4, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_get5(IntPtr handle, long i1, long i2, long i3, long i4, long i5);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set5(IntPtr handle, long i1, long i2, long i3, long i4, long i5, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_get6(IntPtr handle, long i1, long i2, long i3, long i4, long i5, long i6);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_set6(IntPtr handle, long i1, long i2, long i3, long i4, long i5, long i6, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_index_select(IntPtr tensor, long dim, IntPtr index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_select(IntPtr tensor, long dim, long index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adjoint(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_argwhere(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_take(IntPtr tensor, IntPtr index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_take_along_dim_dflt(IntPtr tensor, IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_take_along_dim(IntPtr tensor, IntPtr indices, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_index_add(IntPtr tensor, long dim, IntPtr index, IntPtr source, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_index_add_(IntPtr tensor, long dim, IntPtr index, IntPtr source, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_index_copy(IntPtr tensor, long dim, IntPtr index, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_index_copy_(IntPtr tensor, long dim, IntPtr index, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_index_fill(IntPtr tensor, long dim, IntPtr index, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_index_fill_(IntPtr tensor, long dim, IntPtr index, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_reshape(IntPtr tensor, IntPtr shape, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_flatten(IntPtr tensor, long start, long end);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_flatten_names(IntPtr tensor, IntPtr names, long nLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unflatten(IntPtr tensor, long dim, IntPtr shape, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unflatten_names(IntPtr tensor, IntPtr names, IntPtr dims, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_align_to(IntPtr tensor, IntPtr names, long nLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unique(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool sorted, [MarshalAs(UnmanagedType.U1)] bool return_inverse, [MarshalAs(UnmanagedType.U1)] bool return_counts, out IntPtr inverse_indices, out IntPtr counts);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unique_dim(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool sorted, [MarshalAs(UnmanagedType.U1)] bool return_inverse, [MarshalAs(UnmanagedType.U1)] bool return_counts, out IntPtr inverse_indices, out IntPtr counts);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unique_consecutive(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool return_inverse, [MarshalAs(UnmanagedType.U1)] bool return_counts, out IntPtr inverse_indices, out IntPtr counts);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unique_dim_consecutive(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool return_inverse, [MarshalAs(UnmanagedType.U1)] bool return_counts, out IntPtr inverse_indices, out IntPtr counts);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_squeeze(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_squeeze_no_dim(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_t(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mT(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mH(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_transpose(IntPtr tensor, long dim1, long dim2);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_transpose_(IntPtr tensor, long dim1, long dim2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_threshold(IntPtr tensor, IntPtr threshold, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_threshold_(IntPtr tensor, IntPtr threshold, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_tril(IntPtr tensor, long diagonal, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_tril_indices(long row, long col, long offset, sbyte scalar_type, int device_type, int device_index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_triu(IntPtr tensor, long diagonal, [MarshalAs(UnmanagedType.U1)] bool inplace);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_triu_indices(long row, long col, long offset, sbyte scalar_type, int device_type, int device_index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_view(IntPtr tensor, IntPtr shape, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_view_as_complex(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_view_as_real(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_all(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_all_along_dimension(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_amax(IntPtr tensor, IntPtr dim, int dim_len, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_amax_out(IntPtr tensor, IntPtr dim, int dim_len, [MarshalAs(UnmanagedType.U1)] bool keep_dim, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_amin(IntPtr tensor, IntPtr dim, int dim_len, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_amin_out(IntPtr tensor, IntPtr dim, int dim_len, [MarshalAs(UnmanagedType.U1)] bool keep_dim, IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_aminmax(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim, out IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_any(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_any_along_dimension(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_argmax(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_argmax_along_dimension(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_argmin(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_argmin_along_dimension(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_argsort(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool descending);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_deg2rad(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rad2deg(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_copysign(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_count_nonzero(IntPtr tensor, IntPtr dim, int dim_len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cov(IntPtr tensor, long correction, IntPtr fweights, IntPtr aweights);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_corrcoef(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_tile(IntPtr tensor, IntPtr reps, int reps_len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_digamma(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_digamma_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lgamma(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_lgamma_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mvlgamma(IntPtr tensor, long p);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_mvlgamma_(IntPtr tensor, long p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_polygamma(IntPtr tensor, long p);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_polygamma_(IntPtr tensor, long p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_positive(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_softplus(IntPtr tensor, IntPtr beta, IntPtr threshold);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ravel(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_relu(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_relu_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_relu6(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_relu6_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rrelu(IntPtr tensor, double lower, double upper);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_rrelu_(IntPtr tensor, double lower, double upper);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_celu(IntPtr tensor, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_celu_(IntPtr tensor, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hardshrink(IntPtr tensor, IntPtr lambda);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_softshrink(IntPtr tensor, IntPtr lambda);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_elu(IntPtr tensor, IntPtr alpha, IntPtr scale, IntPtr input_scale);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_elu_(IntPtr tensor, IntPtr alpha, IntPtr scale, IntPtr input_scale);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_gelu(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_gelu_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_glu(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hardsigmoid(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_hardsigmoid_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hardswish(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_hardswish_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_hardtanh(IntPtr tensor, IntPtr min, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_hardtanh_(IntPtr tensor, IntPtr min, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_heaviside(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_igamma(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_igammac(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_i0(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isclose(IntPtr tensor, IntPtr other, double rtol, double atol, [MarshalAs(UnmanagedType.U1)] bool nanEqual);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isin(IntPtr elements, IntPtr test_elements, [MarshalAs(UnmanagedType.U1)] bool assume_unique, [MarshalAs(UnmanagedType.U1)] bool invert);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isinf(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isfinite(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isposinf(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isneginf(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isnan(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_is_nonzero(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_isreal(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_leaky_relu(IntPtr tensor, IntPtr negative_slope);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_leaky_relu_(IntPtr tensor, IntPtr negative_slope);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_selu(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_selu_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_silu(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_silu_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_log_sigmoid(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lerp(IntPtr tensor, IntPtr end, IntPtr weight);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_lerp_(IntPtr tensor, IntPtr end, IntPtr weight);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_baddbmm(IntPtr batch1, IntPtr batch2, IntPtr mat, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bmm(IntPtr batch1, IntPtr batch2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cdist(IntPtr x1, IntPtr x2, double p, long compute_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bucketize(IntPtr input, IntPtr boundaries, [MarshalAs(UnmanagedType.U1)] bool out_int32, [MarshalAs(UnmanagedType.U1)] bool right);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bincount(IntPtr tensor, IntPtr weights, long minlength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_channel_shuffle(IntPtr input, long groups);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_clamp(IntPtr input, IntPtr min, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_clamp_tensor(IntPtr input, IntPtr min, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_clamp_(IntPtr input, IntPtr min, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_clamp_tensor_(IntPtr input, IntPtr min, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_clamp_max(IntPtr input, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_clamp_max_(IntPtr input, IntPtr max);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_clamp_min(IntPtr input, IntPtr min);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_clamp_min_(IntPtr input, IntPtr min);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_diff(IntPtr tensor, long n, long dim, IntPtr prepend, IntPtr append);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_diag(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_trace(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_diag_embed(IntPtr tensor, long offset, long dim1, long dim2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_diagflat(IntPtr tensor, long offset);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_diagonal(IntPtr tensor, long offset, long dim1, long dim2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_erf(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_erf_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_erfc(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_erfc_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_erfinv(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_erfinv_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_eq(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_eq_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_eq_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_eq_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTensor_equal(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTensor_allclose(IntPtr tensor, IntPtr trg, double rtol, double atol, [MarshalAs(UnmanagedType.U1)] bool equal_nan);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ge(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_ge_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ge_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_ge_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_gt(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_gt_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_gt_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_gt_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_kron(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lcm(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_lcm_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ldexp(IntPtr right, IntPtr left);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_ldexp_(IntPtr right, IntPtr left);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_le(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_le_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_le_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_le_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lt(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_lt_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lt_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_lt_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_masked_fill(IntPtr tensor, IntPtr mask, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_masked_fill_(IntPtr tensor, IntPtr mask, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_masked_scatter(IntPtr tensor, IntPtr mask, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_masked_scatter_(IntPtr tensor, IntPtr mask, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_masked_select(IntPtr tensor, IntPtr mask);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_topk(IntPtr tensor, AllocatePinnedArray allocator, int k, long dim, [MarshalAs(UnmanagedType.U1)] bool largest, [MarshalAs(UnmanagedType.U1)] bool sorted);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_unbind(IntPtr tensor, AllocatePinnedArray allocator, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unfold(IntPtr tensor, long dim, long size, long step);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_split_with_size(IntPtr tensor, AllocatePinnedArray allocator, long size, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_split_with_sizes(IntPtr tensor, AllocatePinnedArray allocator, IntPtr psizes, int length, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_tensor_split_with_size(IntPtr tensor, AllocatePinnedArray allocator, long size, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_tensor_split_with_tensor_sizes(IntPtr tensor, AllocatePinnedArray allocator, IntPtr indices, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_vsplit_with_size(IntPtr tensor, AllocatePinnedArray allocator, long size);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_vsplit_with_sizes(IntPtr tensor, AllocatePinnedArray allocator, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_hsplit_with_size(IntPtr tensor, AllocatePinnedArray allocator, long size);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_hsplit_with_sizes(IntPtr tensor, AllocatePinnedArray allocator, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_dsplit_with_size(IntPtr tensor, AllocatePinnedArray allocator, long size);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_dsplit_with_sizes(IntPtr tensor, AllocatePinnedArray allocator, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_chunk(IntPtr tensor, AllocatePinnedArray allocator, long chunks, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_kthvalue(IntPtr tensor, long k, long dim, [MarshalAs(UnmanagedType.U1)] bool keepdim, out IntPtr _out);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_max_elementwise(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_max_along_dimension(IntPtr tensor, AllocatePinnedArray allocator, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mean(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_quantile(IntPtr tensor, IntPtr q, long dim, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nanquantile(IntPtr tensor, IntPtr q, long dim, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mode(IntPtr tensor, AllocatePinnedArray allocator, long dim, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mean_along_dimensions(IntPtr tensor, IntPtr dimensions, int length, [MarshalAs(UnmanagedType.U1)] bool keepdim, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_median(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_min(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_min_elementwise(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_min_along_dimension(IntPtr tensor, AllocatePinnedArray allocator, long dim, [MarshalAs(UnmanagedType.U1)] bool keep_dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_msort(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sort(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool descending, [MarshalAs(UnmanagedType.U1)] bool stable, out IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ne(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_ne_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ne_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_ne_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_dist(IntPtr tensor, IntPtr other, float p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_norm(IntPtr tensor, float p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_norm_along_dimension(IntPtr tensor, long dimension, [MarshalAs(UnmanagedType.U1)] bool keepdim, float p);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_outer(IntPtr input, IntPtr vec2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ormqr(IntPtr input, IntPtr tau, IntPtr other, [MarshalAs(UnmanagedType.U1)] bool left, [MarshalAs(UnmanagedType.U1)] bool transpose);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_inner(IntPtr input, IntPtr vec2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_inverse(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_prelu(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fmax(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fmin(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_renorm(IntPtr tensor, float p, long dim, float maxnorm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sigmoid(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sigmoid_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_std(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool unbiased);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_var(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool unbiased);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_std_along_dimensions(IntPtr tensor, IntPtr dimensions, int length, [MarshalAs(UnmanagedType.U1)] bool unbiased, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_var_along_dimensions(IntPtr tensor, IntPtr dimensions, int length, [MarshalAs(UnmanagedType.U1)] bool unbiased, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_std_mean(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool unbiased, out IntPtr mean);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_var_mean(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool unbiased, out IntPtr mean);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_std_mean_along_dimensions(IntPtr tensor, IntPtr dimensions, int length, [MarshalAs(UnmanagedType.U1)] bool unbiased, [MarshalAs(UnmanagedType.U1)] bool keepdim, out IntPtr mean);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_var_mean_along_dimensions(IntPtr tensor, IntPtr dimensions, int length, [MarshalAs(UnmanagedType.U1)] bool unbiased, [MarshalAs(UnmanagedType.U1)] bool keepdim, out IntPtr mean);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sum(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sum_along_dimensions(IntPtr tensor, IntPtr dimensions, int length, [MarshalAs(UnmanagedType.U1)] bool keepdim, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_prod(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_prod_along_dimensions(IntPtr tensor, long dimension, [MarshalAs(UnmanagedType.U1)] bool keepdim, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_expand(IntPtr tensor, IntPtr psizes, int length, [MarshalAs(UnmanagedType.U1)] bool isImplicit);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_repeat(IntPtr tensor, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_repeat_interleave(IntPtr tensor, IntPtr repeats, long dim, long output_size);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_repeat_interleave_int64(IntPtr tensor, long repeats, long dim, long output_size);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_broadcast_to(IntPtr tensor, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_movedim(IntPtr tensor, IntPtr src, int src_len, IntPtr dst, int dst_len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randn_out(IntPtr psizes, int length, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rand_out(IntPtr psizes, int length, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randint_out(long high, IntPtr psizes, int length, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rand_like(IntPtr input, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_tensor_split_with_sizes(IntPtr tensor, AllocatePinnedArray allocator, IntPtr psizes, int length, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randn_like(IntPtr input, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randint_like(IntPtr input, long low, long high, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randperm_out(IntPtr generator, long n, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bernoulli(IntPtr tensor, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_multinomial(IntPtr tensor, long num_samples, [MarshalAs(UnmanagedType.U1)] bool replacement, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_poisson(IntPtr tensor, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bernoulli_0(IntPtr tensor, double p, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bernoulli_1(IntPtr tensor, IntPtr p_tensor, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_binomial(IntPtr count, IntPtr prob, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_cauchy_(IntPtr tensor, double median, double sigma, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_exponential_(IntPtr tensor, double lambda, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_geometric_(IntPtr tensor, double p, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_normal_(IntPtr tensor, double mean, double std, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_log_normal_(IntPtr tensor, double mean, double std, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_random_(IntPtr tensor, double low, double high, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_uniform_(IntPtr tensor, double low, double high, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_arange_out(IntPtr start, IntPtr strp, IntPtr step, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_permute(IntPtr tensor, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ones_out(IntPtr psizes, int length, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_zeros_out(IntPtr psizes, int length, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_zeros_like(IntPtr input, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ones_like(IntPtr input, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_empty_out(IntPtr psizes, int length, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_empty_like(IntPtr input, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_full_out(IntPtr psizes, int length, IntPtr value, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_full_like(IntPtr input, IntPtr value, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_detach(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_detach_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_eye_out(long rows, long columns, IntPtr tensorOut);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_scatter(IntPtr tensor, long dim, IntPtr index, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_scatter_(IntPtr tensor, long dim, IntPtr index, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_scatter_add(IntPtr tensor, long dim, IntPtr index, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_diagonal_scatter(IntPtr tensor, IntPtr source, long offset, long dim1, long dim2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_select_scatter(IntPtr tensor, IntPtr source, long dim, long index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_slice_scatter(IntPtr tensor, IntPtr source, long dim, IntPtr start, IntPtr end, long step);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_scatter_add_(IntPtr tensor, long dim, IntPtr index, IntPtr source);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_gather(IntPtr tensor, long dim, IntPtr index);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_flip(IntPtr tensor, IntPtr psizes, int length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fliplr(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_flipud(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nanmean(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keepdim, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nanmedian(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nansum(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nan_to_num(IntPtr tensor, IntPtr nan, IntPtr posinf, IntPtr neginf);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nextafter(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_narrow(IntPtr tensor, long dim, long start, long length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_nonzero(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_roll(IntPtr tensor, IntPtr shifts, int shLength, IntPtr dims, long dimLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rot90(IntPtr tensor, long k, long dim1, long dim2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_slice(IntPtr tensor, long dim, long start, long length, long step);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_unsqueeze(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_unsqueeze_(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_where(IntPtr condition, IntPtr x, IntPtr y);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_atleast_1d(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_atleast_2d(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_atleast_3d(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_stft(IntPtr x, long n_fft, long hop_length, long win_length, IntPtr window, [MarshalAs(UnmanagedType.U1)] bool normalized, long onesided, [MarshalAs(UnmanagedType.U1)] bool return_complex);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_istft(IntPtr x, long n_fft, long hop_length, long win_length, IntPtr window, [MarshalAs(UnmanagedType.U1)] bool center, [MarshalAs(UnmanagedType.U1)] bool normalized, long onesided, long length, [MarshalAs(UnmanagedType.U1)] bool return_complex);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_arange(IntPtr start, IntPtr stop, IntPtr step, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requireGrad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newComplexFloat32Scalar(float real, float imaginary, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randint(IntPtr generator, long low, long high, IntPtr psizes, int length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTensor_randint_bool(IntPtr generator);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTensor_randint_int(IntPtr generator, int low, int high);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_randint_long(IntPtr generator, long low, long high);

		[DllImport("LibTorchSharp")]
		internal static extern double THSTensor_rand_float(IntPtr generator);

		[DllImport("LibTorchSharp")]
		internal static extern double THSTensor_randn_float(IntPtr generator);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sparse(IntPtr indices, IntPtr values, IntPtr sizes, int length, sbyte type, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_linspace(double start, double end, long steps, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logspace(double start, double end, long steps, double @base, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bartlett_window(long len, [MarshalAs(UnmanagedType.U1)] bool periodic, sbyte scalar_type, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_blackman_window(long len, [MarshalAs(UnmanagedType.U1)] bool periodic, sbyte scalar_type, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hamming_window(long len, [MarshalAs(UnmanagedType.U1)] bool periodic, double alpha, double beta, sbyte scalar_type, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hann_window(long len, [MarshalAs(UnmanagedType.U1)] bool periodic, sbyte scalar_type, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_kaiser_window(long len, [MarshalAs(UnmanagedType.U1)] bool periodic, double beta, sbyte scalar_type, int device_type, int device_index, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newBoolScalar([MarshalAs(UnmanagedType.U1)] bool scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newByteScalar(byte scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newInt8Scalar(sbyte scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newInt16Scalar(short scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newInt32Scalar(int scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newInt64Scalar(long scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newFloat16Scalar(float scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newFloat32Scalar(float scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newFloat64Scalar(double scalar, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newComplexFloat64Scalar(double real, double imaginary, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_frombuffer(IntPtr rawArray, GCHandleDeleter deleter, long count, long offset, sbyte type, sbyte dtype, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_new(IntPtr rawArray, GCHandleDeleter deleter, IntPtr dimensions, int numDimensions, sbyte type, sbyte dtype, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_newInt64(IntPtr rawArray, GCHandleDeleter deleter, IntPtr dimensions, int numDimensions, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rand(IntPtr generator, IntPtr psizes, int length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randn(IntPtr generator, IntPtr psizes, int length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_from_file(byte[] filename, sbyte shared, long size, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_complex(IntPtr real, IntPtr imag);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_polar(IntPtr abs, IntPtr angle);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fft(IntPtr tensor, long n, long dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ifft(IntPtr tensor, long n, long dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fft2(IntPtr tensor, IntPtr s, IntPtr dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ifft2(IntPtr tensor, IntPtr s, IntPtr dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fftn(IntPtr tensor, IntPtr s, int s_length, IntPtr dim, int dim_length, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ifftn(IntPtr tensor, IntPtr s, int s_length, IntPtr dim, int dim_length, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_irfft(IntPtr tensor, long n, long dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rfft(IntPtr tensor, long n, long dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rfft2(IntPtr tensor, IntPtr s, IntPtr dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_irfft2(IntPtr tensor, IntPtr s, IntPtr dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rfftn(IntPtr tensor, IntPtr s, int s_length, IntPtr dim, int dim_length, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_irfftn(IntPtr tensor, IntPtr s, int s_length, IntPtr dim, int dim_length, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hfft(IntPtr tensor, long n, long dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ihfft(IntPtr tensor, long n, long dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fftshift(IntPtr tensor, IntPtr dim, int dim_length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ifftshift(IntPtr tensor, IntPtr dim, int dim_length);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fftfreq(long n, double d, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rfftfreq(long n, double d, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hfft2(IntPtr tensor, IntPtr s, IntPtr dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ihfft2(IntPtr tensor, IntPtr s, IntPtr dim, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hfftn(IntPtr tensor, IntPtr s, int s_length, IntPtr dim, int dim_length, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ihfftn(IntPtr tensor, IntPtr s, int s_length, IntPtr dim, int dim_length, sbyte norm);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_angle(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_asin(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_asin_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_acos(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_acos_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_atan(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_atan_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_atan2_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cos(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_atan2(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_cos_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sin(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sin_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_tan(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_tan_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sinc(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sinc_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sinh(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sinh_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cosh(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_cosh_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_tanh(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_tanh_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_arcsinh(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_arcsinh_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_arccosh(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_arccosh_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_arctanh(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_arctanh_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_block_diag(IntPtr tensor, int len);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_broadcast_tensors(IntPtr tensor, long length, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cat(IntPtr tensor, int len, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cartesian_prod(IntPtr tensor, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_stack(IntPtr tensor, int len, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hstack(IntPtr tensor, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_vstack(IntPtr tensor, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_column_stack(IntPtr tensors, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_row_stack(IntPtr tensor, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_dstack(IntPtr tensor, int len);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSTensor_meshgrid(IntPtr tensor, int len, [MarshalAs(UnmanagedType.LPStr)] string indexing, AllocatePinnedArray allocator);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_standard_gamma_(IntPtr tensor, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sample_dirichlet_(IntPtr tensor, IntPtr gen);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_abs(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_abs_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_add(IntPtr tensor, IntPtr trg, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_add_scalar(IntPtr tensor, IntPtr trg, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_add_(IntPtr tensor, IntPtr trg, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_addmm_(IntPtr mat, IntPtr mat1, IntPtr mat2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_addmv(IntPtr mat, IntPtr mat1, IntPtr vec2, float beta = 1f, float alpha = 1f);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_addmv_(IntPtr mat, IntPtr mat1, IntPtr vec2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_addr(IntPtr mat, IntPtr mat1, IntPtr vec2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_addr_(IntPtr mat, IntPtr mat1, IntPtr vec2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bitwise_and(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_addmm(IntPtr mat, IntPtr mat1, IntPtr mat2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_add_scalar_(IntPtr tensor, IntPtr trg, IntPtr alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_addcdiv(IntPtr tensor, IntPtr tensor1, IntPtr tensor2, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_addbmm(IntPtr mat, IntPtr batch1, IntPtr batch2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_addbmm_(IntPtr mat, IntPtr batch1, IntPtr batch2, float beta, float alpha);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_addcmul(IntPtr tensor, IntPtr tensor1, IntPtr tensor2, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_addcmul_(IntPtr tensor, IntPtr tensor1, IntPtr tensor2, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bitwise_xor(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bitwise_xor_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_addcdiv_(IntPtr tensor, IntPtr tensor1, IntPtr tensor2, IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bitwise_not(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bitwise_not_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bitwise_and_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bitwise_or(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bitwise_or_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bitwise_left_shift(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bitwise_left_shift_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_bitwise_right_shift(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_bitwise_right_shift_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ceil(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_ceil_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_is_conj(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_resolve_conj(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTensor_is_neg(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_resolve_neg(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_cummin(IntPtr tensor, AllocatePinnedArray allocator, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cumsum(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conj(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_conj_physical(IntPtr tensor);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSTensor_div_scalar(IntPtr tensor, IntPtr trg, [MarshalAs(UnmanagedType.LPStr)] string? rounding_mode);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern void THSTensor_div_(IntPtr tensor, IntPtr trg, [MarshalAs(UnmanagedType.LPStr)] string? rounding_mode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_conj_physical_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_cummax(IntPtr tensor, AllocatePinnedArray allocator, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_exp(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_exp_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_exp2(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_expm1(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_floor(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_floor_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_floor_divide(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_floor_divide_(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_floor_divide_scalar(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_floor_divide_scalar_(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_frexp(IntPtr tensor, out IntPtr exponent);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_gcd(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSTensor_div(IntPtr tensor, IntPtr trg, [MarshalAs(UnmanagedType.LPStr)] string? rounding_mode);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_fmod_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fmod_scalar(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_remainder_scalar_(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_round(IntPtr tensor, long decimals);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cumprod(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool has_type, sbyte scalar_type);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern void THSTensor_div_scalar_(IntPtr tensor, IntPtr trg, [MarshalAs(UnmanagedType.LPStr)] string? rounding_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_histc(IntPtr tensor, long bins, long min, long max);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_hypot(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_log10(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_log10_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logcumsumexp(IntPtr tensor, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logsumexp(IntPtr tensor, long dim, [MarshalAs(UnmanagedType.U1)] bool keepdim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logical_or(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_logical_or_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logical_not(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_logical_not_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_mul_scalar_(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_neg(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_reciprocal_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_remainder(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logical_and(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_logical_and_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_pow_scalar(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_pow_scalar_(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_remainder_scalar(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_reciprocal(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_remainder_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cumulative_trapezoid_x(IntPtr y, IntPtr x, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cumulative_trapezoid_dx(IntPtr y, double dx, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_rsqrt_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sqrt(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_float_power(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_fmod_scalar_(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_frac(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logit(IntPtr tensor, IntPtr eps);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mul(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_expm1_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fmod(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_frac_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_gcd_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_log(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_log_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logaddexp(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logaddexp2(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_log2(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_log2_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_log1p_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_log1p(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logical_xor(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_logical_xor_(IntPtr tensor, IntPtr other);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_mul_(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_pow(IntPtr tensor, IntPtr exponent);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_pow_(IntPtr tensor, IntPtr exponent);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mul_scalar(IntPtr tensor, IntPtr scalar);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_neg_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_round_(IntPtr tensor, long decimals);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_rsqrt(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sqrt_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sign(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sign_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sgn(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sgn_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_signbit(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sub(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_sub_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sub_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_sub_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_trapezoid_x(IntPtr y, IntPtr x, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_trapezoid_dx(IntPtr y, double dx, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_true_divide(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_true_divide_(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_true_divide_scalar(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_true_divide_scalar_(IntPtr left, IntPtr right);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_trunc_(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_xlogy(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_xlogy_scalar(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_xlogy_scalar_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_xlogy_(IntPtr tensor, IntPtr trg);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_trunc(IntPtr tensor);

		[DllImport("LibTorchSharp", BestFitMapping = false, CharSet = CharSet.Ansi, ThrowOnUnmappableChar = true)]
		internal static extern IntPtr THSTensor_einsum([MarshalAs(UnmanagedType.LPStr)] string location, IntPtr tensors, int len);

		[DllImport("LibTorchSharp")]
		internal static extern double THSTensor_clip_grad_norm_(IntPtr tensors, int len, double max_norm, double norm_type);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_clip_grad_value_(IntPtr tensors, int len, double clip_value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_parameters_to_vector(IntPtr tensors, int len);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTensor_vector_to_parameters(IntPtr vec, IntPtr tensors, int len);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cholesky(IntPtr input, [MarshalAs(UnmanagedType.U1)] bool upper);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cholesky_inverse(IntPtr input, [MarshalAs(UnmanagedType.U1)] bool upper);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cholesky_solve(IntPtr input, IntPtr input2, [MarshalAs(UnmanagedType.U1)] bool upper);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_cross(IntPtr input, IntPtr other, long dim);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_eig(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool eigenvectors, out IntPtr pEigenvectors);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_matmul(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mm(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_mv(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_matrix_exp(IntPtr input);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_vdot(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_dot(IntPtr tensor, IntPtr target);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_logdet(IntPtr tensor);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lu(IntPtr tensor, [MarshalAs(UnmanagedType.U1)] bool pivot, [MarshalAs(UnmanagedType.U1)] bool get_infos, out IntPtr infos, out IntPtr pivots);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lu_solve(IntPtr tensor, IntPtr LU_data, IntPtr LU_pivots);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lu_unpack(IntPtr LU_data, IntPtr LU_pivots, [MarshalAs(UnmanagedType.U1)] bool unpack_data, [MarshalAs(UnmanagedType.U1)] bool unpack_pivots, out IntPtr L, out IntPtr U);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_zeros(IntPtr psizes, int length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requireGrad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_randperm(IntPtr generator, long n, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requireGrad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_ones(IntPtr psizes, int length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_empty_strided(IntPtr psizes, int sz_length, IntPtr pstrides, int str_length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_empty(IntPtr psizes, int length, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_full(IntPtr psizes, int length, IntPtr value, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_eye(long rows, long columns, sbyte scalarType, int deviceType, int deviceIndex, [MarshalAs(UnmanagedType.U1)] bool requires_grad);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_avg_pool1d(IntPtr input, IntPtr outputSize, int outputSizeLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_avg_pool2d(IntPtr input, IntPtr outputSize, int outputSizeLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_avg_pool3d(IntPtr input, IntPtr outputSize, int outputSizeLength);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_avg_pool3d_backward_out(IntPtr gradInput, IntPtr gradOutput, IntPtr originalInput);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_max_pool1d(IntPtr input, IntPtr outputSize, int outputSizeLength, out IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_max_pool2d(IntPtr input, IntPtr outputSize, int outputSizeLength, out IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_adaptive_max_pool3d(IntPtr input, IntPtr outputSize, int outputSizeLength, out IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fractional_max_pool2d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr outputSize, int outputSizeLength, IntPtr outputRatio, int outputRatioLength, out IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_fractional_max_pool3d(IntPtr input, IntPtr kernelSize, int kernelSizeLength, IntPtr outputSize, int outputSizeLength, IntPtr outputRatio, int outputRatioLength, out IntPtr indices);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lp_pool1d(IntPtr input, double norm_type, IntPtr kernelSize, int kernelSizeLength, IntPtr stride, int strideLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_lp_pool2d(IntPtr input, double norm_type, IntPtr kernelSize, int kernelSizeLength, IntPtr stride, int strideLength, [MarshalAs(UnmanagedType.U1)] bool ceil_mode);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_searchsorted_t(IntPtr sorted_sequence, IntPtr values, bool out_int32, bool right, IntPtr sorter);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_searchsorted_s(IntPtr sorted_sequence, IntPtr values, bool out_int32, bool right, IntPtr sorter);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_histogram_t(IntPtr input, IntPtr bins, IntPtr weight, bool density, out IntPtr r_bin_edges);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_histogram_i(IntPtr input, long bins, IntPtr range, int length, IntPtr weight, bool density, out IntPtr r_bin_edges);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_histogram_out_t(IntPtr input, IntPtr bins, IntPtr weight, bool density, out IntPtr hist, out IntPtr bin_edges, out IntPtr r_bin_edges);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTensor_histogram_out_i(IntPtr input, long bins, IntPtr range, int length, IntPtr weight, bool density, out IntPtr hist, out IntPtr bin_edges, out IntPtr r_bin_edges);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTorch_scalar_to_bool(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorch_dispose_scalar(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern byte THSTorch_scalar_type(IntPtr value);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTorch_can_cast(int type1, int type2);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTorch_promote_types(int type1, int type2);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_uint8_to_scalar(byte value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_int8_to_scalar(sbyte value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_int16_to_scalar(short value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_int32_to_scalar(int value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_int64_to_scalar(long value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_float32_to_scalar(float value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_float64_to_scalar(double value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_complex32_to_scalar(float real, float imaginary);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_complex64_to_scalar(double real, double imaginary);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_bool_to_scalar([MarshalAs(UnmanagedType.U1)] bool value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_float16_to_scalar(float value);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_bfloat16_to_scalar(float value);

		[DllImport("LibTorchSharp")]
		internal static extern float THSTorch_scalar_to_float32(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorch_scalar_to_bfloat16(IntPtr value, out ushort res);

		[DllImport("LibTorchSharp")]
		internal static extern double THSTorch_scalar_to_float64(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern sbyte THSTorch_scalar_to_int8(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern byte THSTorch_scalar_to_uint8(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern short THSTorch_scalar_to_int16(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTorch_scalar_to_int32(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern long THSTorch_scalar_to_int64(IntPtr handle);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorch_scalar_to_complex32(IntPtr handle, out float real, out float imaginary);

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorch_scalar_to_complex64(IntPtr handle, out double real, out double imaginary);

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_get_and_reset_last_err();

		[DllImport("LibTorchSharp")]
		internal static extern IntPtr THSTorch_lstsq(IntPtr handle, IntPtr b, out IntPtr qr);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTorch_get_num_threads();

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorch_set_num_threads(int threads);

		[DllImport("LibTorchSharp")]
		internal static extern int THSTorch_get_num_interop_threads();

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorch_set_num_interop_threads(int threads);

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTorchCuda_is_available();

		[DllImport("LibTorchSharp")]
		[return: MarshalAs(UnmanagedType.U1)]
		internal static extern bool THSTorchCuda_cudnn_is_available();

		[DllImport("LibTorchSharp")]
		internal static extern int THSTorchCuda_device_count();

		[DllImport("LibTorchSharp")]
		internal static extern void THSTorchCuda_synchronize(long device_index);
	}
	internal struct TensorOrScalar
	{
		public long TypeCode;

		public long ArrayIndex;

		public IntPtr Handle;
	}
}
namespace TorchSharp.Modules
{
	public class DataLoader : DataLoader<Dictionary<string, torch.Tensor>, Dictionary<string, torch.Tensor>>
	{
		public DataLoader(torch.utils.data.Dataset dataset, int batchSize, IEnumerable<long> shuffler, torch.Device device = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
			: base((torch.utils.data.Dataset<Dictionary<string, torch.Tensor>>)dataset, batchSize, (Func<IEnumerable<Dictionary<string, torch.Tensor>>, torch.Device, Dictionary<string, torch.Tensor>>)Collate, shuffler, device, num_worker, drop_last, disposeBatch, disposeDataset)
		{
		}

		public DataLoader(torch.utils.data.Dataset dataset, int batchSize, bool shuffle = false, torch.Device device = null, int? seed = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
			: base((torch.utils.data.Dataset<Dictionary<string, torch.Tensor>>)dataset, batchSize, (Func<IEnumerable<Dictionary<string, torch.Tensor>>, torch.Device, Dictionary<string, torch.Tensor>>)Collate, shuffle, device, seed, num_worker, drop_last, disposeBatch, disposeDataset)
		{
		}

		private static Dictionary<string, torch.Tensor> Collate(IEnumerable<Dictionary<string, torch.Tensor>> dic, torch.Device device)
		{
			using (torch.NewDisposeScope())
			{
				Dictionary<string, torch.Tensor> dictionary = new Dictionary<string, torch.Tensor>();
				foreach (string x in dic.First().Keys)
				{
					torch.Tensor tensor = torch.cat(dic.Select((Dictionary<string, torch.Tensor> k) => k[x].unsqueeze(0L)).ToArray(), 0L);
					if (tensor.device_type != device.type || tensor.device_index != device.index)
					{
						tensor = tensor.to(device);
					}
					dictionary[x] = tensor.MoveToOuterDisposeScope();
				}
				return dictionary;
			}
		}
	}
	public class IterableDataLoader : DataLoader<IList<torch.Tensor>, IList<torch.Tensor>>
	{
		public IterableDataLoader(torch.utils.data.IterableDataset dataset, int batchSize, IEnumerable<long> shuffler, torch.Device device = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
			: base((torch.utils.data.Dataset<IList<torch.Tensor>>)dataset, batchSize, (Func<IEnumerable<IList<torch.Tensor>>, torch.Device, IList<torch.Tensor>>)Collate, shuffler, device, num_worker, drop_last, disposeBatch, disposeDataset)
		{
		}

		public IterableDataLoader(torch.utils.data.IterableDataset dataset, int batchSize, bool shuffle = false, torch.Device device = null, int? seed = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
			: base((torch.utils.data.Dataset<IList<torch.Tensor>>)dataset, batchSize, (Func<IEnumerable<IList<torch.Tensor>>, torch.Device, IList<torch.Tensor>>)Collate, shuffle, device, seed, num_worker, drop_last, disposeBatch, disposeDataset)
		{
		}

		private static IList<torch.Tensor> Collate(IEnumerable<IList<torch.Tensor>> dic, torch.Device device)
		{
			using (torch.NewDisposeScope())
			{
				List<torch.Tensor> list = new List<torch.Tensor>();
				int x;
				for (x = 0; x < dic.First().Count; x++)
				{
					torch.Tensor tensor = torch.cat(dic.Select((IList<torch.Tensor> k) => k[x].unsqueeze(0L)).ToArray(), 0L);
					if (tensor.device_type != device.type || tensor.device_index != device.index)
					{
						tensor = tensor.to(device);
					}
					list.Add(tensor.MoveToOuterDisposeScope());
				}
				return list;
			}
		}
	}
	public class DataLoader<T, S> : IEnumerable<S>, IEnumerable, IDisposable
	{
		private sealed class DataLoaderEnumerator : IEnumerator<S>, IEnumerator, IDisposable
		{
			private readonly DataLoader<T, S> loader;

			private IEnumerator<long> shuffler;

			private HashSet<IDisposable>? currentDisposables;

			private S? current;

			public S Current => current;

			object IEnumerator.Current => current;

			public DataLoaderEnumerator(DataLoader<T, S> loader)
			{
				this.loader = loader;
				shuffler = null;
				Reset();
			}

			private static void DisposeAll(HashSet<IDisposable> disposables)
			{
				foreach (IDisposable disposable in disposables)
				{
					disposable.Dispose();
				}
			}

			public bool MoveNext()
			{
				DisposeCurrent();
				long[] indices = (from _ in Enumerable.Range(0, loader.batch_size)
					select (!shuffler.MoveNext()) ? ((long?)null) : new long?(shuffler.Current) into x
					where x.HasValue
					select x).Cast<long>().ToArray();
				if (indices.Length == 0)
				{
					return false;
				}
				if (loader.drop_last && indices.Length < loader.batch_size)
				{
					return false;
				}
				T[] tensors = new T[indices.Length];
				HashSet<IDisposable>[] getTensorDisposables = new HashSet<IDisposable>[indices.Length];
				Enumerable.Range(0, indices.Length).AsParallel().WithDegreeOfParallelism(loader.num_workers)
					.ForAll(delegate(int i)
					{
						using DisposeScope disposeScope2 = torch.NewDisposeScope();
						tensors[i] = loader.dataset.GetTensor(indices[i]);
						getTensorDisposables[i] = disposeScope2.DetachAllAndDispose();
					});
				using DisposeScope disposeScope = torch.NewDisposeScope();
				current = loader.collate_fn(tensors, loader.Device);
				HashSet<IDisposable> hashSet = disposeScope.DetachAllAndDispose();
				if (loader.DisposeBatch)
				{
					currentDisposables = hashSet;
				}
				HashSet<IDisposable>[] array = getTensorDisposables;
				for (int num = 0; num < array.Length; num++)
				{
					DisposeAll(array[num]);
				}
				return true;
			}

			public void Reset()
			{
				DisposeCurrent();
				shuffler?.Dispose();
				shuffler = loader.sampler.GetEnumerator();
			}

			public void Dispose()
			{
				shuffler.Dispose();
				DisposeCurrent();
			}

			private void DisposeCurrent()
			{
				if (currentDisposables != null)
				{
					DisposeAll(currentDisposables);
					currentDisposables = null;
				}
			}
		}

		public torch.utils.data.Dataset<T> dataset { get; }

		public int batch_size { get; }

		public bool drop_last { get; }

		public IEnumerable<long> sampler { get; }

		public int num_workers { get; }

		public Func<IEnumerable<T>, torch.Device, S> collate_fn { get; }

		public torch.Device Device { get; }

		public bool DisposeBatch { get; }

		public bool DisposeDataset { get; }

		public long Count
		{
			get
			{
				if (!drop_last)
				{
					return (dataset.Count - 1) / batch_size + 1;
				}
				return dataset.Count / batch_size;
			}
		}

		public DataLoader(torch.utils.data.Dataset<T> dataset, int batchSize, Func<IEnumerable<T>, torch.Device, S> collate_fn, IEnumerable<long> shuffler, torch.Device? device = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
		{
			this.dataset = dataset;
			batch_size = batchSize;
			this.drop_last = drop_last;
			Device = device ?? torch.CPU;
			sampler = shuffler;
			num_workers = Math.Max(num_worker, 1);
			this.collate_fn = collate_fn;
			DisposeBatch = disposeBatch;
			DisposeDataset = disposeDataset;
		}

		public DataLoader(torch.utils.data.Dataset<T> dataset, int batchSize, Func<IEnumerable<T>, torch.Device, S> collate_fn, bool shuffle = false, torch.Device? device = null, int? seed = null, int num_worker = 1, bool drop_last = false, bool disposeBatch = true, bool disposeDataset = true)
			: this(dataset, batchSize, collate_fn, shuffle ? new FisherYatesShuffler(dataset.Count, seed) : LongRange(dataset.Count), device, num_worker, drop_last, disposeBatch, disposeDataset)
		{
		}

		private static IEnumerable<long> LongRange(long count)
		{
			for (long i = 0L; i < count; i++)
			{
				yield return i;
			}
		}

		public IEnumerator<S> GetEnumerator()
		{
			return new DataLoaderEnumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing && DisposeDataset)
			{
				dataset.Dispose();
			}
		}
	}
	public class Bernoulli : torch.distributions.Distribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		public override torch.Tensor mean => probs;

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => probs * (1 - probs));

		public torch.Tensor probs => _probs ?? LogitsToProbs(_logits, isBinary: true);

		public torch.Tensor logits => _logits ?? ProbsToLogits(_probs, isBinary: true);

		public Bernoulli(torch.Tensor p = null, torch.Tensor l = null, torch.Generator generator = null)
			: base(generator)
		{
			if (((object)p == null && (object)l == null) || ((object)p != null && (object)l != null))
			{
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}
			base.batch_shape = (((object)p == null) ? l.size() : p.size());
			_probs = p?.alias().DetachFromDisposeScope();
			_logits = l?.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			long[] sizes = ExtendedShape(sample_shape);
			return torch.bernoulli(probs.expand(sizes), generator);
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(logits, value);
			return -torch.nn.functional.binary_cross_entropy_with_logits(list[0], list[1], null, torch.nn.Reduction.None);
		}

		public override torch.Tensor entropy()
		{
			return torch.nn.functional.binary_cross_entropy_with_logits(logits, probs, null, torch.nn.Reduction.None);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Bernoulli))
			{
				throw new ArgumentException("expand(): 'instance' must be a Bernoulli distribution");
			}
			torch.Tensor p = _probs?.expand(batch_shape);
			torch.Tensor l = _logits?.expand(batch_shape);
			Bernoulli bernoulli = ((instance == null) ? new Bernoulli(p, l, generator) : instance) as Bernoulli;
			bernoulli.batch_shape = batch_shape;
			if (bernoulli == instance)
			{
				bernoulli._probs = p;
				bernoulli._logits = l;
			}
			return bernoulli;
		}
	}
	public class Beta : torch.distributions.ExponentialFamily
	{
		protected Dirichlet dirichlet;

		private torch.Tensor concentration1;

		private torch.Tensor concentration0;

		public override torch.Tensor mean => concentration1 / (concentration1 + concentration0);

		public override torch.Tensor mode => dirichlet.mode[new torch.TensorIndex[2]
		{
			torch.TensorIndex.Ellipsis,
			0L
		}];

		public override torch.Tensor variance
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = concentration0 + concentration1;
					return (concentration1 * concentration0 / (tensor.pow(2) * (tensor + 1))).MoveToOuterDisposeScope();
				}
			}
		}

		protected override IList<torch.Tensor> NaturalParams => new torch.Tensor[2] { concentration1, concentration0 };

		protected override torch.Tensor MeanCarrierMeasure => new torch.Tensor(IntPtr.Zero);

		public Beta(torch.Tensor concentration1, torch.Tensor concentration0, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(concentration1, concentration0);
			this.concentration1 = list[0].DetachFromDisposeScope();
			this.concentration0 = list[1].DetachFromDisposeScope();
			dirichlet = new Dirichlet(torch.stack(list, -1L), generator);
			base.batch_shape = dirichlet.batch_shape;
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				dirichlet?.Dispose();
				concentration0?.Dispose();
				concentration1?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			return dirichlet.rsample(sample_shape).select(-1L, 0L);
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			torch.Tensor value2 = torch.stack(new torch.Tensor[2]
			{
				value,
				1.0 - value
			}, -1L);
			return dirichlet.log_prob(value2);
		}

		public override torch.Tensor entropy()
		{
			return dirichlet.entropy();
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Beta))
			{
				throw new ArgumentException("expand(): 'instance' must be a Beta distribution");
			}
			torch.Tensor tensor = concentration0.expand(batch_shape);
			torch.Tensor tensor2 = concentration1.expand(batch_shape);
			Beta beta = ((instance == null) ? new Beta(tensor2, tensor, generator) : instance) as Beta;
			beta.batch_shape = batch_shape;
			if (beta == instance)
			{
				beta.dirichlet = new Dirichlet(torch.stack(new torch.Tensor[2] { tensor2, tensor }, -1L));
				beta.concentration1 = tensor2;
				beta.concentration0 = tensor;
			}
			return beta;
		}

		protected override torch.Tensor LogNormalizer(params torch.Tensor[] parameters)
		{
			torch.Tensor tensor = parameters[0];
			torch.Tensor tensor2 = parameters[1];
			return torch.lgamma(tensor) + torch.lgamma(tensor2) - torch.lgamma(tensor + tensor2);
		}
	}
	public class Binomial : torch.distributions.Distribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		private torch.Tensor total_count;

		public override torch.Tensor mean => total_count * probs;

		public override torch.Tensor variance
		{
			get
			{
				using torch.Tensor tensor = total_count * probs;
				using torch.Tensor tensor2 = 1 - probs;
				return tensor * tensor2;
			}
		}

		public override torch.Tensor mode
		{
			get
			{
				using torch.Tensor tensor = total_count + 1;
				using torch.Tensor tensor2 = tensor * _probs;
				return tensor2.floor_().clamp(null, total_count);
			}
		}

		public torch.Tensor probs => _probs;

		public torch.Tensor logits => _logits;

		public Binomial(torch.Tensor total_count, torch.Tensor p = null, torch.Tensor l = null, torch.Generator generator = null)
			: base(generator)
		{
			base.batch_shape = (((object)p == null) ? l.size() : p.size());
			_probs = p ?? LogitsToProbs(l, isBinary: true).DetachFromDisposeScope();
			_logits = l ?? ProbsToLogits(p, isBinary: true).DetachFromDisposeScope();
			base.generator = generator;
			this.total_count = (((object)p == null) ? torch.broadcast_tensors(total_count, l) : torch.broadcast_tensors(total_count, p))[0].type_as(p ?? l).DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				total_count?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			long[] sizes = ExtendedShape(sample_shape);
			return torch.binomial(total_count.expand(sizes), probs.expand(sizes), generator);
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			torch.Tensor tensor = torch.lgamma(total_count + 1);
			torch.Tensor tensor2 = torch.lgamma(value + 1);
			torch.Tensor tensor3 = torch.lgamma(total_count - value + 1);
			torch.Tensor tensor4 = total_count * ClampByZero(logits) + total_count * torch.log1p(torch.exp(-torch.abs(logits))) - tensor;
			return value * logits - tensor2 - tensor3 - tensor4;
		}

		public override torch.Tensor entropy()
		{
			return torch.nn.functional.binary_cross_entropy_with_logits(logits, probs, null, torch.nn.Reduction.None);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Binomial))
			{
				throw new ArgumentException("expand(): 'instance' must be a Binomial distribution");
			}
			Binomial binomial = ((instance == null) ? new Binomial(total_count.expand(batch_shape), _probs?.expand(batch_shape), logits?.expand(batch_shape), generator) : instance) as Binomial;
			binomial.batch_shape = batch_shape;
			if (binomial == instance)
			{
				binomial.total_count = total_count.expand(batch_shape);
				binomial._probs = _probs?.expand(batch_shape);
				binomial._logits = _logits?.expand(batch_shape);
			}
			return binomial;
		}
	}
	public class Categorical : torch.distributions.Distribution
	{
		internal torch.Tensor _probs;

		internal torch.Tensor _logits;

		internal long num_events;

		public override torch.Tensor mean => torch.full(ExtendedShape(), double.NaN, probs.dtype, probs.device);

		public override torch.Tensor variance => torch.full(ExtendedShape(), double.NaN, probs.dtype, probs.device);

		public torch.Tensor probs => _probs ?? LogitsToProbs(_logits);

		public torch.Tensor logits => _logits ?? ProbsToLogits(_probs);

		public long[] param_shape
		{
			get
			{
				if ((object)_probs != null)
				{
					return _probs.shape;
				}
				return _logits.shape;
			}
		}

		public Categorical(torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(generator)
		{
			torch.Tensor tensor = (((object)probs == null) ? logits : probs);
			_probs = (((object)probs != null) ? (probs / probs.sum(-1L, keepdim: true)).DetachFromDisposeScope() : null);
			_logits = (((object)logits != null) ? (logits - logits.logsumexp(-1L, keepdim: true)).DetachFromDisposeScope() : null);
			num_events = tensor.size(-1);
			base.batch_shape = ((tensor.ndim > 1) ? tensor.shape.Take(tensor.shape.Length - 1).ToArray() : new long[0]);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			return torch.multinomial(probs.reshape(-1L, num_events), sample_shape.Aggregate(1L, (long x, long y) => x * y), replacement: true, generator).T.reshape(ExtendedShape(sample_shape));
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			value = value.@long().unsqueeze(-1L);
			IList<torch.Tensor> list = torch.broadcast_tensors(value, logits);
			value = list[0][new torch.TensorIndex[2]
			{
				torch.TensorIndex.Ellipsis,
				torch.TensorIndex.Slice(null, 1L)
			}];
			return list[1].gather(-1L, value).squeeze(-1L);
		}

		public override torch.Tensor entropy()
		{
			double min = torch.finfo(logits.dtype).min;
			return -(torch.clamp(logits, min) * probs).sum(-1L);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Categorical))
			{
				throw new ArgumentException("expand(): 'instance' must be a Categorical distribution");
			}
			List<long> list = new List<long>();
			list.AddRange(batch_shape);
			list.Add(num_events);
			long[] sizes = list.ToArray();
			torch.Tensor tensor = _probs?.expand(sizes);
			torch.Tensor tensor2 = _logits?.expand(sizes);
			Categorical categorical = ((instance == null) ? new Categorical(tensor, tensor2, generator) : instance) as Categorical;
			categorical.batch_shape = batch_shape;
			if (categorical == instance)
			{
				categorical.num_events = num_events;
				categorical._probs = tensor;
				categorical._logits = tensor2;
			}
			return categorical;
		}
	}
	public class Cauchy : torch.distributions.Distribution
	{
		private torch.Tensor loc;

		private torch.Tensor scale;

		private torch.Tensor _mean;

		private torch.Tensor _variance;

		public override torch.Tensor mode => loc;

		public override torch.Tensor mean => _mean;

		public override torch.Tensor variance => _variance;

		public Cauchy(torch.Tensor loc, torch.Tensor scale, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(loc, scale);
			this.loc = list[0].DetachFromDisposeScope();
			this.scale = list[1].DetachFromDisposeScope();
			_mean = torch.full(ExtendedShape(), double.NaN, loc.dtype, loc.device).DetachFromDisposeScope();
			_variance = torch.full(ExtendedShape(), double.PositiveInfinity, loc.dtype, loc.device).DetachFromDisposeScope();
			base.batch_shape = this.loc.size();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				loc?.Dispose();
				scale?.Dispose();
				_mean?.Dispose();
				_variance?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			long[] size = ExtendedShape(sample_shape);
			torch.Tensor tensor = loc.new_empty(size).cauchy_(0.0, 1.0, generator);
			return loc + tensor * scale;
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => 0.0 - Math.Log(Math.PI) - scale.log() - ((value - loc) / scale).pow(2).log1p());
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => Math.Log(Math.PI * 4.0) + scale.log());
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => torch.atan((value - loc) / scale) / Math.PI + 0.5);
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => torch.tan(Math.PI * (value - 0.5)) * scale + loc);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Cauchy))
			{
				throw new ArgumentException("expand(): 'instance' must be a Cauchy distribution");
			}
			Cauchy cauchy = ((instance == null) ? new Cauchy(loc.expand(batch_shape), scale.expand(batch_shape), generator) : instance) as Cauchy;
			cauchy.batch_shape = batch_shape;
			if (cauchy == instance)
			{
				cauchy.loc = loc.expand(batch_shape);
				cauchy.scale = scale.expand(batch_shape);
			}
			return cauchy;
		}
	}
	public class Chi2 : Gamma
	{
		public torch.Tensor df => concentration * 2;

		public Chi2(torch.Tensor df, torch.Generator generator = null)
			: base(df * 0.5, torch.tensor(0.5), generator)
		{
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Chi2))
			{
				throw new ArgumentException("expand(): 'instance' must be a Chi2 distribution");
			}
			if (instance == null)
			{
				instance = new Chi2(concentration, generator);
			}
			return base.expand(batch_shape, instance);
		}
	}
	public class Dirichlet : torch.distributions.ExponentialFamily
	{
		internal torch.Tensor concentration;

		public override torch.Tensor mean => torch.WrappedTensorDisposeScope(() => concentration / concentration.sum(-1L, keepdim: true));

		public override torch.Tensor mode
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = (concentration - 1).clamp(0.0);
					torch.Tensor tensor2 = tensor / tensor.sum(-1L, keepdim: true);
					torch.Tensor tensor3 = (concentration < 1).all(-1L);
					tensor2[new torch.Tensor[1] { tensor3 }] = torch.nn.functional.one_hot(tensor2[new torch.Tensor[1] { tensor3 }].argmax(-1L), tensor.shape[tensor.ndim - 1]).to(tensor2);
					return tensor2.MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor variance
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = concentration.sum(-1L, keepdim: true);
					return (concentration * (tensor - concentration) / (tensor.pow(2) * (tensor + 1))).MoveToOuterDisposeScope();
				}
			}
		}

		protected override IList<torch.Tensor> NaturalParams => new torch.Tensor[1] { concentration - 1 };

		protected override torch.Tensor MeanCarrierMeasure => new torch.Tensor(IntPtr.Zero);

		public Dirichlet(torch.Tensor concentration, torch.Generator generator = null)
			: base(generator)
		{
			long[] shape = concentration.shape;
			base.batch_shape = shape.Take(shape.Length - 1).ToArray();
			base.event_shape = new long[1] { shape[^1] };
			this.concentration = concentration.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				concentration?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			long[] sizes = ExtendedShape(sample_shape);
			return torch._sample_dirichlet(concentration.expand(sizes), generator);
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			return (concentration - 1).xlogy(value).sum(-1L) + torch.lgamma(concentration.sum(-1L)) - torch.lgamma(concentration).sum(-1L);
		}

		public override torch.Tensor entropy()
		{
			long num = concentration.size(-1);
			torch.Tensor tensor = concentration.sum(-1L);
			return torch.lgamma(concentration).sum(-1L) - torch.lgamma(tensor) - (num - tensor) * torch.digamma(tensor) - ((concentration - 1.0) * torch.digamma(concentration)).sum(-1L);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Dirichlet))
			{
				throw new ArgumentException("expand(): 'instance' must be a Dirichlet distribution");
			}
			List<long> list = new List<long>();
			list.AddRange(batch_shape);
			list.AddRange(base.event_shape);
			torch.Tensor tensor = concentration.expand(list.ToArray());
			Dirichlet dirichlet = ((instance == null) ? new Dirichlet(tensor, generator) : instance) as Dirichlet;
			dirichlet.batch_shape = batch_shape;
			if (dirichlet == instance)
			{
				dirichlet.concentration = tensor;
			}
			return dirichlet;
		}

		protected override torch.Tensor LogNormalizer(params torch.Tensor[] parameters)
		{
			torch.Tensor tensor = parameters[0];
			return tensor.lgamma().sum(-1L) - tensor.sum(-1L).lgamma();
		}
	}
	public class Exponential : torch.distributions.ExponentialFamily
	{
		private torch.Tensor rate;

		public override torch.Tensor mean => rate.reciprocal();

		public override torch.Tensor mode => torch.zeros_like(rate);

		public override torch.Tensor variance => rate.pow(2);

		public override torch.Tensor stddev => rate.reciprocal();

		protected override IList<torch.Tensor> NaturalParams => new torch.Tensor[1] { -rate };

		protected override torch.Tensor MeanCarrierMeasure => torch.tensor(0L, rate.dtype, rate.device);

		public Exponential(torch.Tensor rate, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(rate);
			base.batch_shape = rate.size();
			this.rate = list[0].DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				rate?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			long[] size = ExtendedShape(sample_shape);
			return rate.new_empty(size).exponential_(1.0, generator) / rate;
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => rate.log() - rate * value);
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => 1 - rate.log());
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => 1 - torch.exp(-rate * value));
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => -torch.log(1 - value) / rate);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Exponential))
			{
				throw new ArgumentException("expand(): 'instance' must be a Exponential distribution");
			}
			torch.Tensor tensor = rate.expand(batch_shape);
			Exponential exponential = ((instance == null) ? new Exponential(tensor, generator) : instance) as Exponential;
			exponential.batch_shape = batch_shape;
			if (exponential == instance)
			{
				exponential.rate = tensor;
			}
			return exponential;
		}

		protected override torch.Tensor LogNormalizer(params torch.Tensor[] parameters)
		{
			return -torch.log(-parameters[0]);
		}
	}
	public class ExpRelaxedCategorical : torch.distributions.Distribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		private torch.Tensor _temperature;

		private Categorical _categorical;

		public torch.Tensor probs => _categorical.probs;

		public torch.Tensor logits => _categorical.logits;

		public torch.Tensor temperature => _temperature;

		public override torch.Tensor mean => new torch.Tensor(IntPtr.Zero);

		public override torch.Tensor mode => base.mode;

		public override torch.Tensor variance => new torch.Tensor(IntPtr.Zero);

		public override torch.Tensor stddev => base.stddev;

		public long[] param_shape => _categorical.param_shape;

		internal ExpRelaxedCategorical(torch.Tensor temperature, torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(generator)
		{
			_categorical = torch.distributions.Categorical(probs, logits, generator);
			_probs = probs?.alias().DetachFromDisposeScope();
			_logits = logits?.alias().DetachFromDisposeScope();
			_temperature = temperature.alias().DetachFromDisposeScope();
			_init(_categorical.batch_shape, _categorical.event_shape);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				_temperature?.Dispose();
				_categorical?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is ExpRelaxedCategorical))
			{
				throw new ArgumentException("expand(): 'instance' must be a ExpRelaxedCategorical distribution");
			}
			ExpRelaxedCategorical expRelaxedCategorical = ((instance == null) ? new ExpRelaxedCategorical(temperature, _probs, _logits, generator) : instance) as ExpRelaxedCategorical;
			expRelaxedCategorical.batch_shape = batch_shape;
			if (expRelaxedCategorical == instance)
			{
				expRelaxedCategorical._temperature = _temperature;
				expRelaxedCategorical._categorical = _categorical.expand(batch_shape) as Categorical;
			}
			return expRelaxedCategorical;
		}

		public override torch.Tensor sample(params long[] sample_shape)
		{
			return rsample(sample_shape);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] size = ExtendedShape(sample_shape);
				torch.Tensor tensor = -(-ClampProbs(torch.rand(size, _logits.dtype, _logits.device)).log()).log();
				torch.Tensor tensor2 = (_logits + tensor) / _temperature;
				return (tensor2 - tensor2.logsumexp(-1L, keepdim: true)).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				float num = _categorical.num_events;
				IList<torch.Tensor> list = torch.broadcast_tensors(_logits, value);
				torch.Tensor tensor = list[0];
				value = list[1];
				torch.Tensor tensor2 = torch.full_like(_temperature, num).lgamma() - _temperature.log().mul(0f - (num - 1f));
				torch.Tensor tensor3 = tensor - value.mul(_temperature);
				return ((tensor3 - tensor3.logsumexp(-1L, keepdim: true)).sum(-1L) + tensor2).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			throw new NotImplementedException();
		}
	}
	public class FisherSnedecor : torch.distributions.Distribution
	{
		private torch.Tensor df1;

		private torch.Tensor df2;

		private Gamma gamma1;

		private Gamma gamma2;

		public override torch.Tensor mean
		{
			get
			{
				torch.Tensor tensor = df2.clone();
				tensor[new torch.Tensor[1] { tensor <= 2 }] = torch.tensor(float.NaN);
				return tensor / (tensor - 2);
			}
		}

		public override torch.Tensor variance
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = df2.clone();
					tensor[new torch.Tensor[1] { tensor <= 4 }] = torch.tensor(float.NaN);
					return (2 * tensor.pow(2) * (df1 + tensor - 2) / (df1 * (tensor - 2).pow(2) * (tensor - 4))).MoveToOuterDisposeScope();
				}
			}
		}

		public FisherSnedecor(torch.Tensor df1, torch.Tensor df2, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(df1, df2);
			this.df1 = list[0].DetachFromDisposeScope();
			this.df2 = list[1].DetachFromDisposeScope();
			gamma1 = new Gamma(this.df1 * 0.5, this.df1, generator);
			gamma2 = new Gamma(this.df2 * 0.5, this.df2, generator);
			base.batch_shape = this.df1.size();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				df1?.Dispose();
				df2?.Dispose();
				gamma1?.Dispose();
				gamma2?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] shape = ExtendedShape(sample_shape);
				torch.Tensor tensor = gamma1.rsample(sample_shape).view(shape);
				torch.Tensor tensor2 = gamma2.rsample(sample_shape).view(shape);
				double tiny = torch.finfo(tensor2.dtype).tiny;
				tensor2.clamp_(tiny);
				return (tensor / tensor2).clamp_(tiny).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = df1 * 0.5;
				torch.Tensor tensor2 = df2 * 0.5;
				torch.Tensor tensor3 = df1 / df2;
				torch.Tensor tensor4 = (tensor + tensor2).lgamma() - tensor.lgamma() - tensor2.lgamma();
				torch.Tensor tensor5 = tensor * tensor3.log() + (tensor - 1) * torch.log(value);
				torch.Tensor tensor6 = (tensor + tensor2) * torch.log1p(tensor3 * value);
				return (tensor4 + tensor5 - tensor6).MoveToOuterDisposeScope();
			}
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is FisherSnedecor))
			{
				throw new ArgumentException("expand(): 'instance' must be a FisherSnedecor distribution");
			}
			torch.Tensor tensor = df1.expand(batch_shape);
			torch.Tensor tensor2 = df2.expand(batch_shape);
			FisherSnedecor fisherSnedecor = ((instance == null) ? new FisherSnedecor(tensor, tensor2, generator) : instance) as FisherSnedecor;
			fisherSnedecor.batch_shape = batch_shape;
			if (fisherSnedecor == instance)
			{
				fisherSnedecor.df1 = tensor;
				fisherSnedecor.df2 = tensor2;
				fisherSnedecor.gamma1 = gamma1.expand(batch_shape) as Gamma;
				fisherSnedecor.gamma2 = gamma2.expand(batch_shape) as Gamma;
			}
			return fisherSnedecor;
		}

		public override torch.Tensor entropy()
		{
			throw new NotImplementedException();
		}
	}
	public class Gamma : torch.distributions.ExponentialFamily
	{
		protected torch.Tensor concentration;

		private torch.Tensor rate;

		public override torch.Tensor mean => torch.WrappedTensorDisposeScope(() => concentration / rate);

		public override torch.Tensor mode => torch.WrappedTensorDisposeScope(() => ((concentration - 1) / rate).clamp_(0));

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => concentration / rate.pow(2));

		protected override IList<torch.Tensor> NaturalParams => new torch.Tensor[2]
		{
			concentration - 1,
			rate
		};

		protected override torch.Tensor MeanCarrierMeasure => torch.tensor(0L, rate.dtype, rate.device);

		public Gamma(torch.Tensor concentration, torch.Tensor rate, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(concentration, rate);
			this.concentration = list[0].DetachFromDisposeScope();
			this.rate = list[1].DetachFromDisposeScope();
			base.batch_shape = this.concentration.size();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				rate?.Dispose();
				concentration?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] sizes = ExtendedShape(sample_shape);
				torch.Tensor tensor = torch._standard_gamma(concentration.expand(sizes), generator) / rate.expand(sizes);
				return tensor.detach().clamp_(torch.finfo(tensor.dtype).tiny).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				value = torch.as_tensor(value, rate.dtype, rate.device);
				return (concentration * rate.log() + (concentration - 1) * value.log() - rate * value - torch.lgamma(concentration)).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => concentration - rate.log() + concentration.lgamma() + (1.0 - concentration) * concentration.digamma());
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => torch.special.gammainc(concentration, rate * value));
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Gamma))
			{
				throw new ArgumentException("expand(): 'instance' must be a Gamma distribution");
			}
			torch.Tensor tensor = concentration.expand(batch_shape);
			torch.Tensor tensor2 = rate.expand(batch_shape);
			Gamma gamma = ((instance == null) ? new Gamma(tensor, tensor2, generator) : instance) as Gamma;
			gamma.batch_shape = batch_shape;
			if (gamma == instance)
			{
				gamma.concentration = tensor;
				gamma.rate = tensor2;
			}
			return gamma;
		}

		protected override torch.Tensor LogNormalizer(params torch.Tensor[] parameters)
		{
			torch.Tensor tensor = parameters[0];
			torch.Tensor tensor2 = parameters[1];
			return torch.lgamma(tensor + 1) + (tensor + 1) * torch.log(-tensor2.reciprocal());
		}
	}
	public class Geometric : torch.distributions.Distribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		public override torch.Tensor mean => 1 / (probs - 1);

		public override torch.Tensor variance => (1f / probs - 1f) / probs;

		public torch.Tensor probs => _probs ?? LogitsToProbs(_logits, isBinary: true);

		public torch.Tensor logits => _logits ?? ProbsToLogits(_probs);

		public Geometric(torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(generator)
		{
			base.batch_shape = (((object)probs == null) ? logits.size() : probs.size());
			_probs = probs?.alias().DetachFromDisposeScope();
			_logits = logits?.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] size = ExtendedShape(sample_shape);
				double tiny = torch.finfo(probs.dtype).tiny;
				using (torch.no_grad())
				{
					return (probs.new_empty(size).uniform_(tiny, 1.0, generator).log() / (-probs).log1p()).floor().MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				IList<torch.Tensor> list = torch.broadcast_tensors(value, probs);
				value = list[0];
				torch.Tensor tensor = list[1].clone();
				tensor[new torch.Tensor[1] { (tensor == 1) & (value == 0) }] = torch.tensor(0);
				return (value * (-tensor).log1p() + probs.log()).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			return torch.nn.functional.binary_cross_entropy_with_logits(logits, probs, null, torch.nn.Reduction.None);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Geometric))
			{
				throw new ArgumentException("expand(): 'instance' must be a Geometric distribution");
			}
			Geometric geometric = ((instance == null) ? new Geometric(_probs?.expand(batch_shape), logits?.expand(batch_shape), generator) : instance) as Geometric;
			geometric.batch_shape = batch_shape;
			if (geometric == instance)
			{
				geometric._probs = _probs?.expand(batch_shape);
				geometric._logits = _logits?.expand(batch_shape);
			}
			return geometric;
		}
	}
	public class Gumbel : TransformedDistribution
	{
		private torch.Tensor loc;

		private torch.Tensor scale;

		private readonly double pioversqrtsix = 1.282549830161864;

		public override torch.Tensor mean => torch.WrappedTensorDisposeScope(() => loc + scale * 0.5772156649015329);

		public override torch.Tensor mode => loc;

		public override torch.Tensor variance => stddev.pow(2);

		public override torch.Tensor stddev => pioversqrtsix * scale;

		internal Gumbel(torch.Tensor loc, torch.Tensor scale, torch.distributions.Distribution base_distribution, torch.distributions.transforms.Transform[] transforms, torch.Generator generator = null)
			: base(base_distribution, transforms, generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(loc, scale);
			base.batch_shape = loc.size();
			this.loc = list[0].DetachFromDisposeScope();
			this.scale = list[1].DetachFromDisposeScope();
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = (loc - value) / scale;
				return (tensor - tensor.exp() - scale.log()).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => scale.log() + 1.5772156649015328);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				loc?.Dispose();
				scale?.Dispose();
			}
			base.Dispose(disposing);
		}
	}
	public class HalfCauchy : TransformedDistribution
	{
		public torch.Tensor scale { get; private set; }

		public override torch.Tensor mean => torch.full(ExtendedShape(), double.PositiveInfinity, scale.dtype, scale.device);

		public override torch.Tensor mode => torch.zeros_like(scale);

		public override torch.Tensor variance => base_distribution.variance;

		internal HalfCauchy(torch.Tensor scale, torch.Generator generator = null)
			: base(torch.distributions.Cauchy(torch.tensor(0).to(scale.dtype), scale, generator), new torch.distributions.transforms.AbsTransform(), generator)
		{
			this.scale = scale?.alias().DetachFromDisposeScope();
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				value = torch.as_tensor(value, scale.dtype, scale.device);
				torch.Tensor x = base_distribution.log_prob(value) + Math.Log(2.0);
				x = torch.where(value >= 0, x, double.NegativeInfinity);
				return x.MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return 2 * base_distribution.cdf(value) - 1;
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			return base_distribution.icdf((value + 1) / 2);
		}

		public override torch.Tensor entropy()
		{
			return base_distribution.entropy() - Math.Log(2.0);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			HalfCauchy instance2 = ((instance == null) ? new HalfCauchy(scale.expand(batch_shape), generator) : instance) as HalfCauchy;
			return base.expand(batch_shape, (torch.distributions.Distribution)instance2);
		}
	}
	public class HalfNormal : TransformedDistribution
	{
		public torch.Tensor scale { get; private set; }

		public override torch.Tensor mean => scale * Math.Sqrt(2.0 / Math.PI);

		public override torch.Tensor mode => torch.zeros_like(scale);

		public override torch.Tensor variance => scale.pow(2) * 0.3633802276324186;

		internal HalfNormal(torch.Tensor scale, torch.Generator generator = null)
			: base(torch.distributions.Normal(torch.tensor(0).to(scale.dtype), scale, generator), new torch.distributions.transforms.Transform[1]
			{
				new torch.distributions.transforms.AbsTransform()
			}, generator)
		{
			this.scale = scale?.alias().DetachFromDisposeScope();
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor x = base_distribution.log_prob(value) + Math.Log(2.0);
				x = torch.where(value >= 0, x, double.NegativeInfinity);
				return x.MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => 2 * base_distribution.cdf(value) - 1);
		}

		public override torch.Tensor icdf(torch.Tensor prob)
		{
			return torch.WrappedTensorDisposeScope(() => base_distribution.icdf((prob + 1) / 2));
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => base_distribution.entropy() - Math.Log(2.0));
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			HalfNormal instance2 = ((instance == null) ? new HalfNormal(scale.expand(batch_shape), generator) : instance) as HalfNormal;
			return base.expand(batch_shape, (torch.distributions.Distribution)instance2);
		}
	}
	public class Independent : torch.distributions.Distribution
	{
		private torch.distributions.Distribution base_dist;

		private int reinterpreted_batch_ndims;

		public override torch.Tensor mean => base_dist.mean;

		public override torch.Tensor mode => base_dist.mode;

		public override torch.Tensor variance => base_dist.variance;

		public Independent(torch.distributions.Distribution base_distribution, int reinterpreted_batch_ndims, torch.Generator generator = null)
			: base(generator)
		{
			long[] array = base_distribution.batch_shape.Concat(base_distribution.event_shape).ToArray();
			int num = reinterpreted_batch_ndims + base_distribution.event_shape.Length;
			long[] array2 = array.Take(array.Length - num).ToArray();
			long[] array3 = array.Skip(array.Length - num).ToArray();
			base_dist = base_distribution;
			this.reinterpreted_batch_ndims = reinterpreted_batch_ndims;
			_init(array2, array3);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				base_dist?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor sample(params long[] sample_shape)
		{
			return base_dist.sample(sample_shape);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			return base_dist.rsample(sample_shape);
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			return torch.distributions.transforms.Transform._sum_rightmost(base_dist.log_prob(value), reinterpreted_batch_ndims);
		}

		public override torch.Tensor entropy()
		{
			return torch.distributions.transforms.Transform._sum_rightmost(base_dist.entropy(), reinterpreted_batch_ndims);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Independent))
			{
				throw new ArgumentException("expand(): 'instance' must be a Independent distribution");
			}
			Independent independent = ((instance == null) ? new Independent(base_dist.expand(batch_shape + base.event_shape.Slice(0, reinterpreted_batch_ndims)), reinterpreted_batch_ndims, generator) : instance) as Independent;
			if (independent == instance)
			{
				independent._init(batch_shape, base.event_shape);
			}
			return independent;
		}
	}
	public class Kumaraswamy : TransformedDistribution
	{
		public torch.Tensor concentration1 { get; private set; }

		public torch.Tensor concentration0 { get; private set; }

		public override torch.Tensor mean => moments(concentration1, concentration0, 1);

		public override torch.Tensor mode
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = concentration0.reciprocal() * (-concentration0).log1p() - (-concentration0 * concentration1).log1p();
					tensor[new torch.Tensor[1] { (concentration0 < 1) | (concentration1 < 1) }] = double.NaN;
					return tensor.exp().MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor variance => moments(concentration1, concentration0, 2) - torch.pow(mean, 2);

		internal Kumaraswamy(torch.Tensor concentration1, torch.Tensor concentration0, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(concentration1, concentration0);
			this.concentration1 = list[0].DetachFromDisposeScope();
			this.concentration0 = list[1].DetachFromDisposeScope();
			_init(torch.distributions.Uniform(torch.full_like(this.concentration0, 0), torch.full_like(this.concentration0, 1)), new torch.distributions.transforms.Transform[3]
			{
				new torch.distributions.transforms.PowerTransform(this.concentration0.reciprocal()),
				new torch.distributions.transforms.AffineTransform(1.0, -1.0),
				new torch.distributions.transforms.PowerTransform(this.concentration1.reciprocal())
			});
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				concentration0?.Dispose();
				concentration1?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor entropy()
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = 1 - concentration1.reciprocal();
				torch.Tensor tensor2 = 1 - concentration0.reciprocal();
				torch.Tensor tensor3 = torch.digamma(concentration0 + 1) + 0.5772156649015329;
				return (tensor2 + tensor * tensor3 - torch.log(concentration1) - torch.log(concentration0)).MoveToOuterDisposeScope();
			}
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			Kumaraswamy kumaraswamy = ((instance == null) ? new Kumaraswamy(concentration1.expand(batch_shape), concentration0.expand(batch_shape), generator) : instance) as Kumaraswamy;
			if (kumaraswamy == instance)
			{
				kumaraswamy.concentration0 = concentration0.expand(batch_shape);
				kumaraswamy.concentration1 = concentration1.expand(batch_shape);
			}
			return base.expand(batch_shape, (torch.distributions.Distribution)kumaraswamy);
		}

		private torch.Tensor moments(torch.Tensor a, torch.Tensor b, int n)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = 1 + n / a;
				torch.Tensor input = torch.lgamma(tensor) + torch.lgamma(b) - torch.lgamma(tensor + b);
				return (b * torch.exp(input)).MoveToOuterDisposeScope();
			}
		}
	}
	public class Laplace : torch.distributions.Distribution
	{
		private torch.Tensor loc;

		private torch.Tensor scale;

		public override torch.Tensor mean => loc;

		public override torch.Tensor mode => loc;

		public override torch.Tensor stddev => scale * Math.Sqrt(2.0);

		public override torch.Tensor variance => 2 * scale.pow(2);

		public Laplace(torch.Tensor loc, torch.Tensor scale, torch.Generator generator = null)
			: base(generator)
		{
			base.batch_shape = loc.size();
			IList<torch.Tensor> list = torch.broadcast_tensors(loc, scale);
			this.loc = list[0].DetachFromDisposeScope();
			this.scale = list[1].DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				loc?.Dispose();
				scale?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] size = ExtendedShape(sample_shape);
				torch.FInfo fInfo = torch.finfo(loc.dtype);
				torch.Tensor tensor = loc.new_empty(size).uniform_(fInfo.eps - 1.0, 1.0);
				torch.empty(size, loc.dtype, loc.device).normal_(0.0, 1.0, generator);
				return (loc - scale * tensor.sign() * torch.log1p(-tensor.abs())).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => -torch.log(2 * scale) - torch.abs(value - loc) / scale);
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => 1 + torch.log(2 * scale));
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => 0.5 - 0.5 * (value - loc).sign() * torch.expm1(-(value - loc).abs() / scale));
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = value - 0.5;
				return (loc - scale * tensor.sign() * torch.log1p(-2 * tensor.abs())).MoveToOuterDisposeScope();
			}
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Laplace))
			{
				throw new ArgumentException("expand(): 'instance' must be a Normal distribution");
			}
			Laplace laplace = ((instance == null) ? new Laplace(loc.expand(batch_shape), scale.expand(batch_shape), generator) : instance) as Laplace;
			laplace.batch_shape = batch_shape;
			if (laplace == instance)
			{
				laplace.loc = loc.expand(batch_shape);
				laplace.scale = scale.expand(batch_shape);
			}
			return laplace;
		}
	}
	public class LogitRelaxedBernoulli : torch.distributions.Distribution
	{
		private torch.Tensor _temperature;

		private torch.Tensor _probs;

		private torch.Tensor _logits;

		public override torch.Tensor mean => probs;

		public override torch.Tensor variance => probs * (1 - probs);

		public torch.Tensor probs => _probs ?? LogitsToProbs(_logits, isBinary: true);

		public torch.Tensor logits => _logits ?? ProbsToLogits(_probs);

		public LogitRelaxedBernoulli(torch.Tensor temperature, torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(generator)
		{
			_temperature = temperature.alias().DetachFromDisposeScope();
			if (((object)probs == null && (object)logits == null) || ((object)probs != null && (object)logits != null))
			{
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}
			base.batch_shape = (((object)probs == null) ? logits.size() : probs.size());
			_probs = probs?.alias().DetachFromDisposeScope();
			_logits = logits?.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				_temperature?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] array = ExtendedShape(sample_shape);
				torch.Tensor tensor = ClampProbs(_probs.expand(array));
				torch.Tensor tensor2 = ClampProbs(torch.rand(array, tensor.dtype, tensor.device));
				return ((tensor2.log() - (-tensor2).log1p() + tensor.log() - (-tensor).log1p()) / _temperature).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				IList<torch.Tensor> list = torch.broadcast_tensors(logits, value);
				torch.Tensor tensor = list[0] - list[1].mul(_temperature);
				return (_temperature.log() + tensor - 2 * tensor.exp().log1p()).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			return torch.nn.functional.binary_cross_entropy_with_logits(logits, probs, null, torch.nn.Reduction.None);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Bernoulli))
			{
				throw new ArgumentException("expand(): 'instance' must be a Bernoulli distribution");
			}
			torch.Tensor tensor = _probs?.expand(batch_shape);
			torch.Tensor tensor2 = _logits?.expand(batch_shape);
			LogitRelaxedBernoulli logitRelaxedBernoulli = ((instance == null) ? new LogitRelaxedBernoulli(_temperature, tensor, tensor2, generator) : instance) as LogitRelaxedBernoulli;
			logitRelaxedBernoulli.batch_shape = batch_shape;
			if (logitRelaxedBernoulli == instance)
			{
				logitRelaxedBernoulli._probs = tensor;
				logitRelaxedBernoulli._logits = tensor2;
				logitRelaxedBernoulli._temperature = _temperature;
			}
			return logitRelaxedBernoulli;
		}
	}
	public class LogNormal : TransformedDistribution
	{
		public torch.Tensor loc { get; private set; }

		public torch.Tensor scale { get; private set; }

		public override torch.Tensor mean => torch.WrappedTensorDisposeScope(() => (loc + scale.pow(2) / 2).exp());

		public override torch.Tensor mode => torch.WrappedTensorDisposeScope(() => (loc - scale.square()).exp());

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => (scale.pow(2).exp() - 1) * (2 * loc + scale.pow(2)).exp());

		internal LogNormal(torch.Tensor loc, torch.Tensor scale, torch.Generator generator = null)
			: base(torch.distributions.Normal(loc, scale, generator), new torch.distributions.transforms.Transform[1]
			{
				new torch.distributions.transforms.ExpTransform()
			}, generator)
		{
			this.loc = loc.alias().DetachFromDisposeScope();
			this.scale = scale.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				loc?.Dispose();
				scale?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor entropy()
		{
			return base_distribution.entropy() + loc;
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			LogNormal instance2 = ((instance == null) ? new LogNormal(loc.expand(batch_shape), scale.expand(batch_shape), generator) : instance) as LogNormal;
			return base.expand(batch_shape, (torch.distributions.Distribution)instance2);
		}
	}
	public class Multinomial : torch.distributions.Distribution
	{
		private int total_count;

		private Categorical categorical;

		public override torch.Tensor mean => total_count * probs;

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => total_count * probs * (1 - probs));

		public torch.Tensor probs => categorical.probs;

		public torch.Tensor logits => categorical.logits;

		public long[] param_shape => categorical.param_shape;

		public Multinomial(int total_count, torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(generator)
		{
			this.total_count = total_count;
			categorical = new Categorical(probs, logits);
			base.batch_shape = categorical.batch_shape;
			long[] array = categorical.param_shape;
			base.event_shape = new long[1] { array[^1] };
		}

		private Multinomial(int total_count, Categorical categorical, torch.Generator generator = null)
			: base(generator)
		{
			this.total_count = total_count;
			this.categorical = categorical;
			base.batch_shape = categorical.batch_shape;
			long[] array = categorical.param_shape;
			base.event_shape = new long[1] { array[^1] };
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				categorical?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			List<long> list = new List<long>();
			list.Add(total_count);
			list.AddRange(sample_shape);
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = categorical.sample(list.ToArray());
				List<int> list2 = Enumerable.Range(0, (int)tensor.dim()).ToList();
				int item = list2[0];
				list2.RemoveAt(0);
				list2.Add(item);
				tensor = tensor.permute(((IEnumerable<int>)list2).Select((Func<int, long>)((int i) => i)).ToArray());
				torch.Tensor tensor2 = tensor.new_zeros(ExtendedShape(sample_shape));
				tensor2.scatter_add_(-1L, tensor, torch.ones_like(tensor));
				return tensor2.type_as(probs).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				IList<torch.Tensor> list = torch.broadcast_tensors(logits, value);
				torch.Tensor tensor = list[0].clone();
				value = list[1];
				torch.Tensor tensor2 = torch.lgamma(value.sum(-1L) + 1);
				torch.Tensor tensor3 = torch.lgamma(value + 1).sum(-1L);
				tensor[new torch.Tensor[1] { (value == 0) & (tensor == float.NegativeInfinity) }] = torch.tensor(0f);
				torch.Tensor tensor4 = (logits * value).sum(-1L);
				return (tensor2 - tensor3 + tensor4).MoveToOuterDisposeScope();
			}
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Multinomial))
			{
				throw new ArgumentException("expand(): 'instance' must be a Multinomial distribution");
			}
			Multinomial multinomial = ((instance == null) ? new Multinomial(total_count, categorical.expand(batch_shape) as Categorical, generator) : instance) as Multinomial;
			if (multinomial == instance)
			{
				multinomial.total_count = total_count;
				multinomial.categorical = categorical.expand(batch_shape) as Categorical;
				multinomial.batch_shape = multinomial.categorical.batch_shape;
				long[] array = multinomial.categorical.param_shape;
				multinomial.event_shape = new long[1] { array[^1] };
			}
			return multinomial;
		}

		public override torch.Tensor entropy()
		{
			throw new NotImplementedException();
		}
	}
	public class MultivariateNormal : torch.distributions.Distribution
	{
		private torch.Tensor loc;

		private torch.Tensor scale_tril;

		private torch.Tensor precision_matrix;

		private torch.Tensor covariance_matrix;

		private torch.Tensor _unbroadcasted_scale_tril;

		public override torch.Tensor mean => loc;

		public override torch.Tensor mode => loc;

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => _unbroadcasted_scale_tril.pow(2).sum(-1L).expand(base.batch_shape + base.event_shape));

		public MultivariateNormal(torch.Tensor loc, torch.Tensor covariance_matrix = null, torch.Tensor precision_matrix = null, torch.Tensor scale_tril = null, torch.Generator generator = null)
			: base(generator)
		{
			if (0 + (((object)covariance_matrix != null) ? 1 : 0) + (((object)precision_matrix != null) ? 1 : 0) + (((object)scale_tril != null) ? 1 : 0) != 1)
			{
				throw new ArgumentException("Exactly one of covariance_matrix or precision_matrix or scale_tril may be specified.");
			}
			using (torch.NewDisposeScope())
			{
				if ((object)scale_tril != null)
				{
					if (scale_tril.dim() < 2)
					{
						throw new ArgumentException("scale_tril matrix must be at least two-dimensional, with optional leading batch dimensions");
					}
					base.batch_shape = torch.broadcast_shapes(TakeAllBut(scale_tril.shape, 2), TakeAllBut(loc.shape, 1));
					this.scale_tril = scale_tril.expand(base.batch_shape + (-1L, -1L)).DetachFromDisposeScope();
					_unbroadcasted_scale_tril = scale_tril;
				}
				else if ((object)covariance_matrix != null)
				{
					if (covariance_matrix.dim() < 2)
					{
						throw new ArgumentException("covariance_matrix matrix must be at least two-dimensional, with optional leading batch dimensions");
					}
					base.batch_shape = torch.broadcast_shapes(TakeAllBut(covariance_matrix.shape, 2).ToArray(), TakeAllBut(loc.shape, 1).ToArray());
					this.covariance_matrix = covariance_matrix.expand(base.batch_shape + (-1L, -1L)).DetachFromDisposeScope();
					_unbroadcasted_scale_tril = torch.linalg.cholesky(covariance_matrix).DetachFromDisposeScope();
				}
				else
				{
					if (precision_matrix.dim() < 2)
					{
						throw new ArgumentException("precision_matrix matrix must be at least two-dimensional, with optional leading batch dimensions");
					}
					base.batch_shape = torch.broadcast_shapes(TakeAllBut(precision_matrix.shape, 2).ToArray(), TakeAllBut(loc.shape, 1).ToArray());
					this.precision_matrix = precision_matrix.expand(base.batch_shape + (-1L, -1L)).DetachFromDisposeScope();
					_unbroadcasted_scale_tril = PrecisionToScaleTril(precision_matrix).DetachFromDisposeScope();
				}
				this.loc = loc.expand(base.batch_shape + -1L).DetachFromDisposeScope();
				base.event_shape = loc.shape[loc.shape.Length - 1];
			}
		}

		private MultivariateNormal(torch.Generator generator = null)
			: base(generator)
		{
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				loc?.Dispose();
				scale_tril?.Dispose();
				precision_matrix?.Dispose();
				covariance_matrix?.Dispose();
				_unbroadcasted_scale_tril?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor bvec = torch.empty(ExtendedShape(sample_shape), loc.dtype, loc.device).normal_(0.0, 1.0, generator);
				return (loc + BatchMV(_unbroadcasted_scale_tril, bvec)).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor bx = value - loc;
				torch.Tensor tensor = BatchMahalanobis(_unbroadcasted_scale_tril, bx);
				torch.Tensor tensor2 = _unbroadcasted_scale_tril.diagonal(0L, -2L, -1L).log().sum(-1L);
				return (-0.5 * ((double)base.event_shape[0] * Math.Log(Math.PI * 2.0) + tensor) - tensor2).MoveToOuterDisposeScope();
			}
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is MultivariateNormal))
			{
				throw new ArgumentException("expand(): 'instance' must be a MultivariateNormal distribution");
			}
			MultivariateNormal obj = ((instance == null) ? new MultivariateNormal(generator) : instance) as MultivariateNormal;
			torch.Size sizes = batch_shape + base.event_shape;
			torch.Size sizes2 = batch_shape + base.event_shape + base.event_shape;
			obj.loc = loc.expand(sizes);
			obj._unbroadcasted_scale_tril = _unbroadcasted_scale_tril;
			obj.scale_tril = scale_tril?.expand(sizes2);
			obj.covariance_matrix = covariance_matrix?.expand(sizes2).DetachFromDisposeScope();
			obj.precision_matrix = precision_matrix?.expand(sizes2).DetachFromDisposeScope();
			obj.batch_shape = batch_shape;
			obj.event_shape = base.event_shape;
			return obj;
		}

		public override torch.Tensor entropy()
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = _unbroadcasted_scale_tril.diagonal(0L, -2L, -1L).log().sum(-1L);
				torch.Tensor tensor2 = 0.5 * (double)base.event_shape[0] * (1.0 + Math.Log(Math.PI * 2.0)) + tensor;
				return ((base.batch_shape.Length == 0) ? tensor2 : tensor2.expand(base.batch_shape)).MoveToOuterDisposeScope();
			}
		}

		private torch.Tensor BatchMV(torch.Tensor bmat, torch.Tensor bvec)
		{
			using (torch.NewDisposeScope())
			{
				return torch.matmul(bmat, bvec.unsqueeze(-1L)).squeeze(-1L).MoveToOuterDisposeScope();
			}
		}

		private IEnumerable<long> Range(long start, long end, long step = 1L)
		{
			List<long> list = new List<long>();
			for (long num = start; num < end; num += step)
			{
				list.Add(num);
			}
			return list;
		}

		private long[] TakeAllBut(long[] input, int count)
		{
			long[] array = new long[input.Length - count];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = input[i];
			}
			return array;
		}

		private torch.Tensor BatchMahalanobis(torch.Tensor bL, torch.Tensor bx)
		{
			using (torch.NewDisposeScope())
			{
				long num = bx.size(-1);
				long[] array = TakeAllBut(bx.shape, 1);
				int num2 = array.Length;
				long num3 = bL.dim() - 2;
				int num4 = num2 - (int)num3;
				long num5 = num4 + num3;
				long num6 = num4 + 2 * num3;
				List<long> list = bx.shape.Take(num4).ToList();
				for (int i = 0; i < bL.ndim - 2; i++)
				{
					long num7 = bL.shape[i];
					long num8 = bx.shape[num4 + i];
					list.Add(num8 / num7);
					list.Add(num7);
				}
				list.Add(num);
				bx = bx.reshape(list.ToArray());
				List<long> list2 = new List<long>();
				list2.AddRange(Range(0L, num4, 1L));
				list2.AddRange(Range(num4, num6, 2L));
				list2.AddRange(Range(num4 + 1, num6, 2L));
				list2.Add(num6);
				bx = bx.permute(list2.ToArray());
				torch.Tensor tensor = bL.reshape(-1L, num, num);
				torch.Tensor b = bx.reshape(-1L, tensor.size(0), num).permute(1L, 2L, 0L);
				torch.Tensor tensor2 = torch.linalg.solve_triangular(tensor, b, upper: false).pow(2).sum(-2L)
					.t()
					.reshape(TakeAllBut(bx.shape, 1));
				List<long> list3 = Range(0L, num4, 1L).ToList();
				for (int j = 0; j < num3; j++)
				{
					list3.Add(num4 + j);
					list3.Add(num5 + j);
				}
				return tensor2.permute(list3).reshape(array).MoveToOuterDisposeScope();
			}
		}

		private torch.Tensor PrecisionToScaleTril(torch.Tensor P)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor a = torch.transpose(torch.flip(torch.linalg.cholesky(torch.flip(P, -2L, -1L)), -2L, -1L), -2L, -1L);
				torch.Tensor b = torch.eye(P.shape[P.shape.Length - 1], -1L, P.dtype, P.device);
				return torch.linalg.solve_triangular(a, b, upper: false).MoveToOuterDisposeScope();
			}
		}
	}
	public class NegativeBinomial : torch.distributions.Distribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		private torch.Tensor total_count;

		public override torch.Tensor mean => total_count * torch.exp(logits);

		public override torch.Tensor mode => torch.WrappedTensorDisposeScope(() => ((total_count - 1) * logits.exp()).floor_().clamp(0));

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => mean / torch.sigmoid(-logits));

		public torch.Tensor probs => _probs;

		public torch.Tensor logits => _logits;

		public NegativeBinomial(torch.Tensor total_count, torch.Tensor p = null, torch.Tensor l = null, torch.Generator generator = null)
			: base(generator)
		{
			base.batch_shape = (((object)p == null) ? l.size() : p.size());
			_probs = p ?? LogitsToProbs(l, isBinary: true).DetachFromDisposeScope();
			_logits = l ?? ProbsToLogits(p, isBinary: true).DetachFromDisposeScope();
			base.generator = generator;
			this.total_count = (((object)p == null) ? torch.broadcast_tensors(total_count, l) : torch.broadcast_tensors(total_count, p))[0].type_as(p ?? l).DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				total_count?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				using (torch.no_grad())
				{
					return torch.poisson(torch.distributions.Gamma(total_count, torch.exp(-_logits)).sample(sample_shape), generator).MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = total_count * (-_logits).log_sigmoid() + value * logits.log_sigmoid();
				torch.Tensor tensor2 = -torch.lgamma(total_count + value) + torch.lgamma(1.0 + value) + torch.lgamma(total_count);
				tensor2 = tensor2.masked_fill(total_count + value == 0, 0);
				return (tensor - tensor2).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			throw new NotImplementedException("entropy");
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is NegativeBinomial))
			{
				throw new ArgumentException("expand(): 'instance' must be a NegativeBinomial distribution");
			}
			NegativeBinomial negativeBinomial = ((instance == null) ? new NegativeBinomial(total_count.expand(batch_shape), _probs?.expand(batch_shape), logits?.expand(batch_shape), generator) : instance) as NegativeBinomial;
			negativeBinomial.batch_shape = batch_shape;
			if (negativeBinomial == instance)
			{
				negativeBinomial.total_count = total_count.expand(batch_shape);
				negativeBinomial._probs = _probs?.expand(batch_shape);
				negativeBinomial._logits = _logits?.expand(batch_shape);
			}
			return negativeBinomial;
		}
	}
	public class Normal : torch.distributions.Distribution
	{
		private torch.Tensor loc;

		private torch.Tensor scale;

		public override torch.Tensor mean => loc;

		public override torch.Tensor mode => loc;

		public override torch.Tensor stddev => scale;

		public override torch.Tensor variance => scale.pow(2);

		public Normal(torch.Tensor loc, torch.Tensor scale, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(loc, scale);
			this.loc = list[0].DetachFromDisposeScope();
			this.scale = list[1].DetachFromDisposeScope();
			base.batch_shape = this.loc.size();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				loc?.Dispose();
				scale?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor sample(params long[] sample_shape)
		{
			long[] sizes = ExtendedShape(sample_shape);
			using (torch.no_grad())
			{
				return torch.normal(loc.expand(sizes), scale.expand(sizes), generator);
			}
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			torch.Tensor tensor = torch.empty(ExtendedShape(sample_shape), loc.dtype, loc.device).normal_(0.0, 1.0, generator);
			return loc + tensor * scale;
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = scale.pow(2);
				torch.Tensor tensor2 = scale.log();
				return (-(value - loc).pow(2) / (2 * tensor) - tensor2 - Math.Log(Math.Sqrt(Math.PI * 2.0))).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => 0.5 + 0.5 * Math.Log(Math.PI * 2.0) + torch.log(scale));
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => 0.5 * (1 + torch.special.erf((value - loc) * scale.reciprocal() / Math.Sqrt(2.0))));
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => loc + scale * torch.special.erfinv(2 * value - 1) * Math.Sqrt(2.0));
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Normal))
			{
				throw new ArgumentException("expand(): 'instance' must be a Normal distribution");
			}
			Normal normal = ((instance == null) ? new Normal(loc.expand(batch_shape), scale.expand(batch_shape), generator) : instance) as Normal;
			normal.batch_shape = batch_shape;
			if (normal == instance)
			{
				normal.loc = loc.expand(batch_shape);
				normal.scale = scale.expand(batch_shape);
			}
			return normal;
		}
	}
	public class OneHotCategorical : torch.distributions.Distribution
	{
		private Categorical _categorical;

		private torch.Tensor _probs;

		private torch.Tensor _logits;

		public override torch.Tensor mean => _categorical._probs;

		public override torch.Tensor mode
		{
			get
			{
				torch.Tensor tensor = _categorical.probs;
				return torch.nn.functional.one_hot(tensor.argmax(-1L), tensor.shape[tensor.ndim - 1]).to(tensor);
			}
		}

		public override torch.Tensor variance => probs * (1 - _categorical.probs);

		public torch.Tensor probs => _probs ?? LogitsToProbs(_logits, isBinary: true);

		public torch.Tensor logits => _logits ?? ProbsToLogits(_probs);

		public OneHotCategorical(torch.Tensor p = null, torch.Tensor l = null, torch.Generator generator = null)
			: base(generator)
		{
			_categorical = new Categorical(p, l, generator);
			if (((object)p == null && (object)logits == null) || ((object)p != null && (object)l != null))
			{
				throw new ArgumentException("One and only one of 'probs' and logits should be provided.");
			}
			base.batch_shape = (((object)p == null) ? l.size() : p.size());
			_probs = p?.alias().DetachFromDisposeScope();
			_logits = l?.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				_categorical?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			torch.Tensor other = _categorical.probs;
			long num_events = _categorical.num_events;
			return torch.nn.functional.one_hot(_categorical.sample(sample_shape), num_events).to(other);
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor item = value.max(-1L).indexes;
				return _categorical.log_prob(item).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			return _categorical.entropy();
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Bernoulli))
			{
				throw new ArgumentException("expand(): 'instance' must be a Bernoulli distribution");
			}
			torch.Tensor p = _probs?.expand(batch_shape);
			torch.Tensor l = _logits?.expand(batch_shape);
			OneHotCategorical oneHotCategorical = ((instance == null) ? new OneHotCategorical(p, l, generator) : instance) as OneHotCategorical;
			oneHotCategorical.batch_shape = batch_shape;
			if (oneHotCategorical == instance)
			{
				oneHotCategorical._probs = p;
				oneHotCategorical._logits = l;
				oneHotCategorical._categorical = _categorical.expand(batch_shape) as Categorical;
			}
			return oneHotCategorical;
		}
	}
	public class Pareto : TransformedDistribution
	{
		public torch.Tensor scale { get; private set; }

		public torch.Tensor alpha { get; private set; }

		public override torch.Tensor mean
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = alpha.clamp(1);
					return (tensor * scale / (tensor - 1)).MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor mode => scale;

		public override torch.Tensor variance
		{
			get
			{
				using (torch.NewDisposeScope())
				{
					torch.Tensor tensor = alpha.clamp(2);
					return (scale.pow(2) * tensor / ((tensor - 1).pow(2) * (tensor - 2))).MoveToOuterDisposeScope();
				}
			}
		}

		internal Pareto(torch.Tensor scale, torch.Tensor alpha, torch.distributions.Distribution base_distribution, torch.distributions.transforms.Transform[] transforms, torch.Generator generator = null)
			: base(base_distribution, transforms, generator)
		{
			this.scale = scale.alias().DetachFromDisposeScope();
			this.alpha = alpha.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				scale?.Dispose();
				alpha?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			Pareto instance2 = ((instance == null) ? torch.distributions.Pareto(scale.expand(batch_shape), alpha.expand(batch_shape), generator) : instance) as Pareto;
			return base.expand(batch_shape, (torch.distributions.Distribution)instance2);
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => (scale / alpha).log() + 1 + alpha.reciprocal());
		}
	}
	public class Poisson : torch.distributions.ExponentialFamily
	{
		private torch.Tensor rate;

		public override torch.Tensor mean => rate;

		public override torch.Tensor variance => rate;

		public override torch.Tensor mode => rate.floor();

		protected override IList<torch.Tensor> NaturalParams => new torch.Tensor[1] { rate.log() };

		protected override torch.Tensor MeanCarrierMeasure => new torch.Tensor(IntPtr.Zero);

		public Poisson(torch.Tensor rate, torch.Generator generator = null)
			: base(generator)
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(rate);
			base.batch_shape = rate.size();
			this.rate = list[0].alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				rate?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				long[] sizes = ExtendedShape(sample_shape);
				using (torch.no_grad())
				{
					return torch.poisson(rate.expand(sizes), generator).MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				IList<torch.Tensor> list = torch.broadcast_tensors(rate, value);
				torch.Tensor tensor = list[0];
				_ = list[1];
				return (value.xlogy(tensor) - tensor - (value + 1).lgamma()).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => 1 - torch.exp(-rate * value));
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => -torch.log(1 - value) / rate);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Poisson))
			{
				throw new ArgumentException("expand(): 'instance' must be a Poisson distribution");
			}
			torch.Tensor tensor = rate.expand(batch_shape);
			Poisson poisson = ((instance == null) ? new Poisson(tensor, generator) : instance) as Poisson;
			poisson.batch_shape = batch_shape;
			if (poisson == instance)
			{
				poisson.rate = tensor;
			}
			return poisson;
		}

		protected override torch.Tensor LogNormalizer(params torch.Tensor[] parameters)
		{
			return parameters[0].exp();
		}
	}
	public class RelaxedBernoulli : TransformedDistribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		private LogitRelaxedBernoulli base_dist => base_distribution as LogitRelaxedBernoulli;

		public torch.Tensor probs => base_dist.probs;

		public torch.Tensor logits => base_dist.logits;

		public torch.Tensor temperature => base_dist.logits;

		public RelaxedBernoulli(torch.Tensor temperature, torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(torch.distributions.LogitRelaxedBernoulli(temperature, probs, logits, generator), new torch.distributions.transforms.SigmoidTransform(), generator)
		{
			_probs = probs?.alias().DetachFromDisposeScope();
			_logits = logits?.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				base_dist?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is RelaxedBernoulli))
			{
				throw new ArgumentException("expand(): 'instance' must be a RelaxedBernoulli distribution");
			}
			RelaxedBernoulli relaxedBernoulli = ((instance == null) ? new RelaxedBernoulli(temperature, _probs, _logits, generator) : instance) as RelaxedBernoulli;
			relaxedBernoulli.batch_shape = batch_shape;
			return base.expand(batch_shape, (torch.distributions.Distribution)relaxedBernoulli);
		}
	}
	public class RelaxedOneHotCategorical : TransformedDistribution
	{
		private torch.Tensor _probs;

		private torch.Tensor _logits;

		private ExpRelaxedCategorical base_dist => base_distribution as ExpRelaxedCategorical;

		public torch.Tensor probs => base_dist.probs;

		public torch.Tensor logits => base_dist.logits;

		public torch.Tensor temperature => base_dist.logits;

		public RelaxedOneHotCategorical(torch.Tensor temperature, torch.Tensor probs = null, torch.Tensor logits = null, torch.Generator generator = null)
			: base(torch.distributions.ExpRelaxedCategorical(temperature, probs, logits, generator), new torch.distributions.transforms.ExpTransform(), generator)
		{
			_probs = probs?.alias().DetachFromDisposeScope();
			_logits = logits?.alias().DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_probs?.Dispose();
				_logits?.Dispose();
				base_dist?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is RelaxedOneHotCategorical))
			{
				throw new ArgumentException("expand(): 'instance' must be a RelaxedOneHotCategorical distribution");
			}
			RelaxedOneHotCategorical relaxedOneHotCategorical = ((instance == null) ? new RelaxedOneHotCategorical(temperature, _probs, _logits, generator) : instance) as RelaxedOneHotCategorical;
			relaxedOneHotCategorical.batch_shape = batch_shape;
			return base.expand(batch_shape, (torch.distributions.Distribution)relaxedOneHotCategorical);
		}
	}
	public class TransformedDistribution : torch.distributions.Distribution
	{
		protected torch.distributions.Distribution base_distribution;

		private torch.distributions.transforms.Transform[] transforms;

		private torch.distributions.transforms.Transform[] reverse_transforms;

		public override torch.Tensor mean => new torch.Tensor(IntPtr.Zero);

		public override torch.Tensor mode => base.mode;

		public override torch.Tensor variance => new torch.Tensor(IntPtr.Zero);

		public override torch.Tensor stddev => base.stddev;

		public TransformedDistribution(torch.Generator generator = null)
			: base(generator)
		{
		}

		public TransformedDistribution(torch.distributions.Distribution base_distribution, torch.distributions.transforms.Transform transform, torch.Generator generator = null)
			: this(base_distribution, new torch.distributions.transforms.Transform[1] { transform }, generator)
		{
			_init(base_distribution, transforms);
		}

		public TransformedDistribution(torch.distributions.Distribution base_distribution, IEnumerable<torch.distributions.transforms.Transform> transforms, torch.Generator generator = null)
			: base(generator)
		{
			_init(base_distribution, transforms.ToArray());
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				base_distribution?.Dispose();
			}
			base.Dispose(disposing);
		}

		protected void _init(torch.distributions.Distribution base_distribution, torch.distributions.transforms.Transform[] transforms)
		{
			this.transforms = transforms;
			reverse_transforms = transforms.Reverse().ToArray();
			long[] array = base_distribution.batch_shape.Concat(base_distribution.event_shape).ToArray();
			int length = base_distribution.event_shape.Length;
			torch.distributions.transforms.ComposeTransform composeTransform = new torch.distributions.transforms.ComposeTransform(transforms.ToArray());
			int event_dim = composeTransform.domain.event_dim;
			long[] array2 = composeTransform.forward_shape(array);
			long[] array3 = composeTransform.inverse_shape(array2);
			if (array != array3)
			{
				long[] array4 = array3.Take(array3.Length - length).ToArray();
				base_distribution = base_distribution.expand(array4);
			}
			_ = event_dim - length;
			_ = 0;
			this.base_distribution = base_distribution;
			int event_dim2 = composeTransform.codomain.event_dim;
			event_dim2 += ((length - event_dim > 0) ? (length - event_dim) : 0);
			int count = array2.Length - event_dim2;
			base.batch_shape = array2.Take(count).ToArray();
			base.event_shape = array2.Skip(count).ToArray();
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.distributions.transforms.Transform[] array = reverse_transforms;
				for (int i = 0; i < array.Length; i++)
				{
					value = array[i]._inverse(value);
				}
				value = base_distribution.cdf(value);
				value = monotonize_cdf(value);
				return value.MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor entropy()
		{
			throw new NotImplementedException();
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is TransformedDistribution))
			{
				throw new ArgumentException("expand(): 'instance' must be a TransformedDistribution distribution");
			}
			long[] array = batch_shape.Concat(base.event_shape).ToArray();
			torch.distributions.transforms.Transform[] array2 = reverse_transforms;
			for (int i = 0; i < array2.Length; i++)
			{
				array = array2[i].inverse_shape(array);
			}
			int num = array.Length - base_distribution.event_shape.Length;
			long[] array3 = new long[num];
			for (int j = 0; j < num; j++)
			{
				array3[j] = array[j];
			}
			TransformedDistribution transformedDistribution = ((instance == null) ? new TransformedDistribution(base_distribution.expand(array3), transforms) : instance) as TransformedDistribution;
			transformedDistribution.batch_shape = batch_shape;
			transformedDistribution.event_shape = base.event_shape;
			if (transformedDistribution == instance)
			{
				transformedDistribution.transforms = transforms;
				transformedDistribution.base_distribution = base_distribution.expand(array3);
			}
			return transformedDistribution;
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				value = monotonize_cdf(value);
				value = base_distribution.icdf(value);
				torch.distributions.transforms.Transform[] array = transforms;
				for (int i = 0; i < array.Length; i++)
				{
					value = array[i].forward(value);
				}
				return value.MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				int num = base.event_shape.Length;
				torch.Tensor tensor = 0.0;
				torch.Tensor tensor2 = value;
				torch.distributions.transforms.Transform[] array = reverse_transforms;
				foreach (torch.distributions.transforms.Transform transform in array)
				{
					torch.Tensor tensor3 = transform._inverse(tensor2);
					num += transform.domain.event_dim - transform.codomain.event_dim;
					tensor -= torch.distributions.transforms.Transform._sum_rightmost(transform.log_abs_det_jacobian(tensor3, tensor2), num - transform.domain.event_dim);
					tensor2 = tensor3;
				}
				tensor += torch.distributions.transforms.Transform._sum_rightmost(base_distribution.log_prob(tensor2), num - base_distribution.event_shape.Length);
				return tensor.MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				using (torch.no_grad())
				{
					torch.Tensor tensor = base_distribution.rsample(sample_shape);
					torch.distributions.transforms.Transform[] array = transforms;
					for (int i = 0; i < array.Length; i++)
					{
						tensor = array[i].forward(tensor);
					}
					return tensor.MoveToOuterDisposeScope();
				}
			}
		}

		public override torch.Tensor sample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				using (torch.no_grad())
				{
					torch.Tensor tensor = base_distribution.sample(sample_shape);
					torch.distributions.transforms.Transform[] array = transforms;
					for (int i = 0; i < array.Length; i++)
					{
						tensor = array[i].forward(tensor);
					}
					return tensor.MoveToOuterDisposeScope();
				}
			}
		}

		private torch.Tensor monotonize_cdf(torch.Tensor value)
		{
			torch.Tensor tensor = 1;
			torch.distributions.transforms.Transform[] array = transforms;
			foreach (torch.distributions.transforms.Transform transform in array)
			{
				tensor *= transform.sign;
			}
			return tensor * (value - 0.5) + 0.5;
		}
	}
	public class Uniform : torch.distributions.Distribution
	{
		private torch.Tensor high;

		private torch.Tensor low;

		public override torch.Tensor mean => torch.WrappedTensorDisposeScope(() => (high + low) / 2);

		public override torch.Tensor mode => double.NaN * high;

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => (high - low).pow(2) / 12);

		public Uniform(torch.Tensor low, torch.Tensor high, torch.Generator generator = null)
			: base(generator, low.size())
		{
			IList<torch.Tensor> list = torch.broadcast_tensors(low, high);
			this.low = list[0].DetachFromDisposeScope();
			this.high = list[1].DetachFromDisposeScope();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				low?.Dispose();
				high?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor rsample(params long[] sample_shape)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = torch.rand(ExtendedShape(sample_shape), low.dtype, low.device, requires_grad: false, generator);
				return (low + tensor * (high - low)).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor log_prob(torch.Tensor value)
		{
			using (torch.NewDisposeScope())
			{
				torch.Tensor tensor = low.le(value).type_as(low);
				torch.Tensor target = high.gt(value).type_as(low);
				return (torch.log(tensor.mul(target)) - torch.log(high - low)).MoveToOuterDisposeScope();
			}
		}

		public override torch.Tensor cdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => ((value - low) / (high - low)).clamp_(0, 1));
		}

		public override torch.Tensor icdf(torch.Tensor value)
		{
			return torch.WrappedTensorDisposeScope(() => (value * (high - low)).add_(low));
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => (high - low).log_());
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			if (instance != null && !(instance is Uniform))
			{
				throw new ArgumentException("expand(): 'instance' must be a Uniform distribution");
			}
			Uniform uniform = ((instance == null) ? new Uniform(low.expand(batch_shape), high.expand(batch_shape), generator) : instance) as Uniform;
			uniform.batch_shape = batch_shape;
			if (uniform == instance)
			{
				uniform.low = low.expand(batch_shape);
				uniform.high = high.expand(batch_shape);
			}
			return uniform;
		}
	}
	public class Weibull : TransformedDistribution
	{
		private torch.Tensor scale;

		private torch.Tensor concentration;

		private torch.Tensor concentration_reciprocal;

		public override torch.Tensor mean => torch.WrappedTensorDisposeScope(() => scale * torch.exp(torch.lgamma(1 + concentration_reciprocal)));

		public override torch.Tensor mode => torch.WrappedTensorDisposeScope(() => scale * ((concentration - 1) / concentration).pow(concentration_reciprocal));

		public override torch.Tensor variance => torch.WrappedTensorDisposeScope(() => scale.pow(2) * (torch.exp(torch.lgamma(1 + 2 * concentration_reciprocal)) - torch.exp(2 * torch.lgamma(1 + concentration_reciprocal))));

		internal Weibull(torch.Tensor scale, torch.Tensor concentration, torch.Tensor concentration_reciprocal, torch.distributions.Distribution base_distribution, torch.distributions.transforms.Transform[] transforms, torch.Generator generator = null)
			: base(base_distribution, transforms, generator)
		{
			this.scale = scale;
			this.concentration = concentration;
			this.concentration_reciprocal = concentration_reciprocal;
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				scale?.Dispose();
				concentration?.Dispose();
				concentration_reciprocal?.Dispose();
			}
			base.Dispose(disposing);
		}

		public override torch.Tensor entropy()
		{
			return torch.WrappedTensorDisposeScope(() => 0.5772156649015329 * (1 - concentration_reciprocal) + torch.log(scale * concentration_reciprocal) + 1);
		}

		public override torch.distributions.Distribution expand(torch.Size batch_shape, torch.distributions.Distribution instance = null)
		{
			torch.Tensor tensor = concentration.expand(batch_shape);
			torch.Tensor exponent = tensor.reciprocal();
			torch.Tensor tensor2 = scale.expand(batch_shape);
			torch.distributions.transforms.Transform[] array = new torch.distributions.transforms.Transform[2]
			{
				new torch.distributions.transforms.PowerTransform(exponent),
				new torch.distributions.transforms.AffineTransform(0, tensor2)
			};
			return ((instance == null) ? new Weibull(tensor2, tensor, exponent, base_distribution.expand(batch_shape), array, generator) : instance) as Weibull;
		}
	}
	public sealed class CELU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double alpha { get; set; }

		public bool inplace { get; set; }

		internal CELU(double alpha, bool inplace)
			: base("CELU")
		{
			this.alpha = alpha;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.celu(tensor, alpha, inplace);
		}
	}
	public sealed class ELU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double alpha { get; set; }

		public bool inplace { get; set; }

		internal ELU(double alpha, bool inplace)
			: base("ELU")
		{
			this.alpha = alpha;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.elu(tensor, alpha, inplace);
		}
	}
	public sealed class GELU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal GELU(bool inplace)
			: base("GELU")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.gelu(tensor, inplace);
		}
	}
	public sealed class GLU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long dim { get; set; }

		internal GLU(long dim)
			: base("GLU")
		{
			this.dim = dim;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.glu(tensor, dim);
		}
	}
	public sealed class Hardshrink : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double lambda { get; set; }

		internal Hardshrink(double lambda = 0.5)
			: base("Hardshrink")
		{
			this.lambda = lambda;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.hardshrink(tensor, lambda);
		}
	}
	public sealed class Hardsigmoid : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Hardsigmoid(bool inplace)
			: base("Hardsigmoid")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.hardsigmoid(tensor, inplace);
		}
	}
	public sealed class Hardswish : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Hardswish(bool inplace = false)
			: base("Hardswish")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.hardswish(tensor, inplace);
		}
	}
	public sealed class Hardtanh : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double min_val { get; set; }

		public double max_val { get; set; }

		public bool inplace { get; set; }

		internal Hardtanh(double min_val = -1.0, double max_val = 1.0, bool inplace = false)
			: base("Hardtanh")
		{
			this.min_val = min_val;
			this.max_val = max_val;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.hardtanh(tensor, min_val, max_val, inplace);
		}

		public override string GetName()
		{
			return typeof(Hardtanh).Name;
		}
	}
	public sealed class LeakyReLU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double negative_slope { get; set; }

		internal LeakyReLU(double negative_slope, bool inplace)
			: base("LeakyReLU")
		{
			this.inplace = inplace;
			this.negative_slope = negative_slope;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.leaky_relu(tensor, negative_slope, inplace);
		}
	}
	public sealed class LogSigmoid : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		internal LogSigmoid()
			: base("LogSigmoid")
		{
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.logsigmoid(tensor);
		}
	}
	public sealed class LogSoftmax : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long dim { get; set; }

		internal LogSoftmax(long dim)
			: base("LogSoftmax")
		{
			this.dim = dim;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.log_softmax(tensor, dim);
		}
	}
	public sealed class Mish : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Mish(bool inplace)
			: base("Mish")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.mish(tensor, inplace);
		}
	}
	public sealed class PReLU : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		[ComponentName(Name = "weight")]
		private Parameter? _weight;

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public long num_parameters { get; private set; }

		public double init { get; private set; }

		internal PReLU(long num_parameters, double init, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("PReLU")
		{
			this.init = init;
			this.num_parameters = num_parameters;
			torch.Tensor tensor = torch.empty(num_parameters, dtype, device);
			tensor.fill_(init);
			weight = new Parameter(tensor);
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.prelu(tensor, weight);
		}

		public override string GetName()
		{
			return typeof(PReLU).Name;
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_weight?.Dispose();
			}
		}
	}
	public sealed class ReLU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal ReLU(bool inplace)
			: base("ReLU")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.relu(tensor, inplace);
		}
	}
	public sealed class ReLU6 : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal ReLU6(bool inplace)
			: base("ReLU6")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.relu6(tensor, inplace);
		}
	}
	public sealed class RReLU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double lower { get; set; }

		public double upper { get; set; }

		public bool inplace { get; set; }

		internal RReLU(double lower, double upper, bool inplace)
			: base("RReLU")
		{
			this.lower = lower;
			this.upper = upper;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.rrelu(tensor, lower, upper, inplace);
		}
	}
	public sealed class SELU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal SELU(bool inplace)
			: base("SELU")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.selu(tensor, inplace);
		}
	}
	public sealed class Sigmoid : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Sigmoid(bool inplace)
			: base("Sigmoid")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.sigmoid(tensor, inplace);
		}
	}
	public sealed class SiLU : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal SiLU(bool inplace)
			: base("SiLU")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.silu(tensor, inplace);
		}

		public override string GetName()
		{
			return typeof(SiLU).Name;
		}
	}
	public sealed class Softmax : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long dim { get; set; }

		internal Softmax(long dim)
			: base("Softmax")
		{
			this.dim = dim;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.softmax(tensor, dim);
		}
	}
	public sealed class Softmax2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		internal Softmax2d()
			: base("Softmax2d")
		{
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.softmax2d(tensor);
		}
	}
	public sealed class Softmin : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long dim { get; set; }

		internal Softmin(long dim)
			: base("Softmin")
		{
			this.dim = dim;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.softmin(tensor, dim);
		}
	}
	public sealed class Softplus : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double beta { get; set; }

		public double threshold { get; set; }

		internal Softplus(double beta = 1.0, double threshold = 20.0)
			: base("Softplus")
		{
			this.beta = beta;
			this.threshold = threshold;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.softplus(tensor, beta, threshold);
		}
	}
	public sealed class Softshrink : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double lambda { get; set; }

		internal Softshrink(double lambda = 0.5)
			: base("Softshrink")
		{
			this.lambda = lambda;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.softshrink(tensor, lambda);
		}
	}
	public sealed class Softsign : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Softsign(bool inplace)
			: base("Softsign")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.softsign(tensor, inplace);
		}
	}
	public sealed class Tanh : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Tanh(bool inplace)
			: base("Tanh")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.tanh(tensor, inplace);
		}

		public override string GetName()
		{
			return typeof(Tanh).Name;
		}
	}
	public sealed class Tanhshrink : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		internal Tanhshrink(bool inplace)
			: base("Tanhshrink")
		{
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.tanhshrink(tensor, inplace);
		}
	}
	public sealed class Threshold : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double threshold { get; set; }

		public double value { get; set; }

		public bool inplace { get; set; }

		internal Threshold(double threshold, double value, bool inplace)
			: base("Threshold")
		{
			this.inplace = inplace;
			this.threshold = threshold;
			this.value = value;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.threshold(tensor, threshold, value, inplace);
		}
	}
	public sealed class AlphaDropout : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double p { get; set; }

		internal AlphaDropout(double p = 0.5, bool inplace = false)
			: base("Dropout1d")
		{
			this.p = p;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.alpha_dropout(tensor, p, training, inplace);
		}
	}
	public sealed class Bilinear : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		private const string WeightComponentName = "weight";

		private const string BiasComponentName = "bias";

		[ComponentName(Name = "bias")]
		private Parameter? _bias;

		[ComponentName(Name = "weight")]
		private Parameter? _weight;

		public Parameter? bias
		{
			get
			{
				return _bias;
			}
			set
			{
				_bias?.Dispose();
				_bias = value?.DetachFromDisposeScope() as Parameter;
				ConditionallyRegisterParameter("bias", _bias);
			}
		}

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public long in1_features { get; set; }

		public long in2_features { get; set; }

		public long out_features { get; set; }

		internal Bilinear(long in1_features, long in2_features, long out_features, bool hasBias = true, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("Bilinear")
		{
			this.in1_features = in1_features;
			this.in2_features = in2_features;
			this.out_features = out_features;
			torch.Device device2 = device;
			weight = torch.empty(out_features, in1_features, in2_features, dtype, device2).AsParameter();
			double num = 1.0 / Math.Sqrt(weight.shape[1]);
			torch.nn.init.uniform_(_weight, 0.0 - num, num);
			if (hasBias)
			{
				device2 = device;
				bias = torch.empty(out_features, dtype, device2).AsParameter();
				torch.nn.init.uniform_(_bias, 0.0 - num, num);
			}
		}

		public override torch.Tensor forward(torch.Tensor input1, torch.Tensor input2)
		{
			return torch.nn.functional.bilinear(input1, input2, _weight, _bias);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_weight?.Dispose();
				_bias?.Dispose();
			}
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			torch.Device device = new torch.Device(deviceType, deviceIndex);
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(_weight.dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(_bias.dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, _weight.device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, _bias.device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}
	}
	public sealed class Conv1d : Convolution
	{
		internal Conv1d(long in_channels, long out_channels, long kernel_size, long stride, long? padding, Padding? padding_type, long dilation, long groups = 1L, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("Conv1d", in_channels, out_channels, new long[1] { kernel_size }, new long[1] { stride }, (!padding.HasValue) ? null : new long[1] { padding.Value }, padding_type, new long[1] { dilation }, transposed: false, new long[1], groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			if (!ValidateShape(input, 1L))
			{
				throw new ArgumentException($"Expected 2D (unbatched) or 3D (batched) input with {base.in_channels} channels to Conv1d.");
			}
			if (base.padding_mode != PaddingModes.Zeros)
			{
				using (torch.Tensor input2 = torch.nn.functional.pad(input, _reversed_padding_repeated_twice, base.padding_mode))
				{
					return torch.nn.functional.conv1d(input2, base.weight, base.bias, base.stride[0], 0L, base.dilation[0], base.groups);
				}
			}
			if (base.padding_type.HasValue)
			{
				return torch.nn.functional.conv1d_padding(input, base.weight, base.bias, base.stride[0], base.padding_type.Value, base.dilation[0], base.groups);
			}
			Parameter parameter = base.weight;
			Parameter? parameter2 = base.bias;
			long? num = base.stride[0];
			long[]? array = base.padding;
			return torch.nn.functional.conv1d(input, parameter, parameter2, num, (array != null) ? new long?(array[0]) : ((long?)null), base.dilation[0], base.groups);
		}
	}
	public sealed class Conv2d : Convolution
	{
		internal Conv2d(long in_channels, long out_channels, (long, long) kernel_size, (long, long) stride, (long, long)? padding, Padding? padding_type, (long, long) dilation, long groups = 1L, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("Conv2d", in_channels, out_channels, new long[2] { kernel_size.Item1, kernel_size.Item2 }, new long[2] { stride.Item1, stride.Item2 }, (!padding.HasValue) ? null : new long[2]
			{
				padding.Value.Item1,
				padding.Value.Item2
			}, padding_type, new long[2] { dilation.Item1, dilation.Item2 }, transposed: false, new long[2], groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			if (!ValidateShape(input, 2L))
			{
				throw new ArgumentException($"Expected 3D (unbatched) or 4D (batched) input with {base.in_channels} channels to Conv2d.");
			}
			if (base.padding_mode != PaddingModes.Zeros)
			{
				using (torch.Tensor input2 = torch.nn.functional.pad(input, _reversed_padding_repeated_twice, base.padding_mode))
				{
					return torch.nn.functional.conv2d(input2, base.weight, base.bias, base.stride, new long[2], base.dilation, base.groups);
				}
			}
			if (base.padding_type.HasValue)
			{
				return torch.nn.functional.conv2d_padding(input, base.weight, base.bias, base.stride, base.padding_type.Value, base.dilation, base.groups);
			}
			return torch.nn.functional.conv2d(input, base.weight, base.bias, base.stride, base.padding, base.dilation, base.groups);
		}
	}
	public sealed class Conv3d : Convolution
	{
		internal Conv3d(long in_channels, long out_channels, (long, long, long) kernel_size, (long, long, long) stride, (long, long, long)? padding, Padding? padding_type, (long, long, long) dilation, long groups = 1L, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("Conv3d", in_channels, out_channels, new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, new long[3] { stride.Item1, stride.Item2, stride.Item3 }, (!padding.HasValue) ? null : new long[3]
			{
				padding.Value.Item1,
				padding.Value.Item2,
				padding.Value.Item3
			}, padding_type, new long[3] { dilation.Item1, dilation.Item2, dilation.Item3 }, transposed: false, new long[3], groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			if (!ValidateShape(input, 3L))
			{
				throw new ArgumentException($"Expected 4D (unbatched) or 5D (batched) input with {base.in_channels} channels to Conv3d.");
			}
			if (base.padding_mode != PaddingModes.Zeros)
			{
				using (torch.Tensor input2 = torch.nn.functional.pad(input, _reversed_padding_repeated_twice, base.padding_mode))
				{
					return torch.nn.functional.conv3d(input2, base.weight, base.bias, base.stride, new long[3], base.dilation, base.groups);
				}
			}
			if (base.padding_type.HasValue)
			{
				return torch.nn.functional.conv3d_padding(input, base.weight, base.bias, base.stride, base.padding_type.Value, base.dilation, base.groups);
			}
			return torch.nn.functional.conv3d(input, base.weight, base.bias, base.stride, base.padding, base.dilation, base.groups);
		}
	}
	public abstract class Convolution : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		private const string WeightComponentName = "weight";

		private const string BiasComponentName = "bias";

		[ComponentName(Name = "bias")]
		protected Parameter? _bias;

		[ComponentName(Name = "weight")]
		protected Parameter? _weight;

		protected long[] _reversed_padding_repeated_twice;

		[Obsolete("Deprecated.", true)]
		protected long input_channels;

		public Parameter? bias
		{
			get
			{
				return _bias;
			}
			set
			{
				_bias?.Dispose();
				_bias = value?.DetachFromDisposeScope() as Parameter;
				ConditionallyRegisterParameter("bias", _bias);
			}
		}

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public long in_channels { get; }

		public long out_channels { get; }

		public bool transposed { get; }

		public Padding? padding_type { get; private set; }

		public long[]? padding { get; private set; }

		public PaddingModes padding_mode { get; set; }

		public long groups { get; set; }

		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] dilation { get; set; }

		public long[] output_padding { get; set; }

		protected Convolution(string name, long in_channels, long out_channels, long[] kernel_size, long[] stride, long[]? padding, Padding? padding_type, long[] dilation, bool transposed, long[] output_padding, long groups, bool bias, PaddingModes padding_mode, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base(name)
		{
			if (transposed && padding_mode != PaddingModes.Zeros)
			{
				throw new ArgumentException("Only PaddingModes.Zeros is supported for ConvTransposeND", "padding_mode");
			}
			this.in_channels = in_channels;
			this.out_channels = out_channels;
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.dilation = dilation;
			this.transposed = transposed;
			this.output_padding = output_padding;
			this.groups = groups;
			this.padding_mode = padding_mode;
			_reversed_padding_repeated_twice = Array.Empty<long>();
			if (padding_type.HasValue)
			{
				SetPadding(padding_type.Value);
			}
			else
			{
				SetPadding(padding ?? Enumerable.Repeat(0L, kernel_size.Length).ToArray());
			}
			long[] array = ((!transposed) ? new long[2]
			{
				out_channels,
				in_channels / groups
			} : new long[2]
			{
				in_channels,
				out_channels / groups
			}).Concat(kernel_size).ToArray();
			long[] size = array;
			torch.Device device2 = device;
			weight = torch.nn.Parameter(torch.empty(size, dtype, device2));
			if (bias)
			{
				device2 = device;
				this.bias = torch.nn.Parameter(torch.empty(out_channels, dtype, device2));
			}
			reset_parameters();
		}

		public void reset_parameters()
		{
			torch.nn.init.kaiming_uniform_(weight, Math.Sqrt(5.0));
			if ((object)bias != null)
			{
				long item = torch.nn.init.CalculateFanInAndFanOut(weight).fanIn;
				if (item != 0L)
				{
					double num = 1.0 / Math.Sqrt(item);
					torch.nn.init.uniform_(bias, 0.0 - num, num);
				}
			}
		}

		public void SetPadding(long[] padding)
		{
			padding_type = null;
			this.padding = padding;
			UpdateReversedPaddingArray();
		}

		public void SetPadding(Padding padding)
		{
			if (transposed)
			{
				throw new ArgumentException("Cannot set padding type on ConvTransposeND");
			}
			this.padding = null;
			padding_type = padding;
			UpdateReversedPaddingArray();
		}

		protected bool ValidateShape(torch.Tensor input, long dimensions)
		{
			long num = input.shape.LongLength;
			if (num != dimensions + 2 || input.shape[1] != in_channels)
			{
				if (num == dimensions + 1)
				{
					return input.shape[0] == in_channels;
				}
				return false;
			}
			return true;
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_weight?.Dispose();
				_bias?.Dispose();
			}
		}

		private void UpdateReversedPaddingArray()
		{
			if (padding != null)
			{
				_reversed_padding_repeated_twice = padding.Reverse().SelectMany((long value) => Enumerable.Repeat(value, 2)).ToArray();
				return;
			}
			_reversed_padding_repeated_twice = Enumerable.Repeat(0L, kernel_size.Length * 2).ToArray();
			if (padding_type == Padding.Same)
			{
				if (stride.Any((long i) => i != 1))
				{
					throw new ArgumentException("padding='same' is not supported for strided convolutions");
				}
				for (int num = kernel_size.Length - 1; num >= 0; num--)
				{
					long num2 = dilation[num] * (kernel_size[num] - 1);
					long num3 = num2 / 2;
					_reversed_padding_repeated_twice[2 * num] = num3;
					_reversed_padding_repeated_twice[2 * num + 1] = num2 - num3;
				}
			}
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			torch.Device device = new torch.Device(deviceType, deviceIndex);
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(_weight.dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(_bias.dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, _weight.device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, _bias.device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		[Obsolete("Deprecated API", true)]
		protected Convolution(IntPtr handle, IntPtr boxedHandle, long input_channels)
			: base(handle, boxedHandle)
		{
			throw new NotImplementedException("Deprecated API.");
		}
	}
	public abstract class ConvolutionTranspose : Convolution
	{
		protected ConvolutionTranspose(string name, long in_channels, long out_channels, long[] kernel_size, long[] stride, long[]? padding, Padding? padding_type, long[] dilation, bool transposed, long[] output_padding, long groups, bool bias, PaddingModes padding_mode, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base(name, in_channels, out_channels, kernel_size, stride, padding, padding_type, dilation, transposed, output_padding, groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return forward(input, null);
		}

		public abstract torch.Tensor forward(torch.Tensor input, long[]? output_size);

		protected long[] _output_padding(torch.Tensor input, long[]? output_size, long[] kernel_size, long[] stride, long[] padding, long[] dilation, long num_spatial_dims)
		{
			if (output_size == null)
			{
				return new long[1] { base.output_padding[0] };
			}
			int num = ((input.dim() != num_spatial_dims + 2) ? 1 : 2);
			if (output_size.Length == num + num_spatial_dims)
			{
				output_size = output_size.Skip(num).ToArray();
			}
			if (output_size.Length != num_spatial_dims)
			{
				throw new ArgumentException($"ConvTranspose{num_spatial_dims}D: for {input.dim()}D input, output_size must have {num_spatial_dims} or {num + num_spatial_dims} elements (got {output_size.Length})", "input");
			}
			List<long> minSizes = new List<long>();
			List<long> list = new List<long>();
			for (int i = 0; i < num_spatial_dims; i++)
			{
				long num2 = (input.size(i + num) - 1) * stride[i] - 2 * padding[i] + dilation[i] * (kernel_size[i] - 1) + 1;
				minSizes.Add(num2);
				list.Add(num2 + stride[i] - 1);
			}
			for (int j = 0; j < output_size.Length; j++)
			{
				long num3 = output_size[j];
				long num4 = minSizes[j];
				long num5 = list[j];
				if (num3 < num4 || num3 > num5)
				{
					throw new ArgumentException($"Requested an output size of {output_size}, but valid sizes range from {num4} to {num5}");
				}
			}
			return (from d in Enumerable.Range(0, (int)num_spatial_dims)
				select output_size[d] - minSizes[d]).ToArray();
		}
	}
	public sealed class ConvTranspose1d : ConvolutionTranspose
	{
		internal ConvTranspose1d(long in_channels, long out_channels, long kernel_size, long stride, long padding, long dilation, long output_padding, long groups = 1L, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("ConvTranspose1d", in_channels, out_channels, new long[1] { kernel_size }, new long[1] { stride }, new long[1] { padding }, null, new long[1] { dilation }, transposed: true, new long[1] { output_padding }, groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, long[]? output_size)
		{
			if (!ValidateShape(input, 1L))
			{
				throw new ArgumentException($"Expected 2D (unbatched) or 3D (batched) input with {base.in_channels} channels to ConvTranspose1d.");
			}
			long[] array = _output_padding(input, output_size, base.kernel_size, base.stride, base.padding, base.dilation, 1L);
			return torch.nn.functional.conv_transpose1d(input, base.weight, base.bias, base.stride[0], base.padding[0], array[0], base.dilation[0], base.groups);
		}
	}
	public sealed class ConvTranspose2d : ConvolutionTranspose
	{
		internal ConvTranspose2d(long in_channels, long out_channels, (long, long) kernel_size, (long, long) stride, (long, long) padding, (long, long) dilation, (long, long) output_padding, long groups = 1L, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("ConvTranspose2d", in_channels, out_channels, new long[2] { kernel_size.Item1, kernel_size.Item2 }, new long[2] { stride.Item1, stride.Item2 }, new long[2] { padding.Item1, padding.Item2 }, null, new long[2] { dilation.Item1, dilation.Item2 }, transposed: true, new long[2] { output_padding.Item1, output_padding.Item2 }, groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, long[]? output_size)
		{
			if (!ValidateShape(input, 2L))
			{
				throw new ArgumentException($"Expected 3D (unbatched) or 4D (batched) input with {base.in_channels} channels to ConvTranspose2d.");
			}
			long[] array = _output_padding(input, output_size, base.kernel_size, base.stride, base.padding, base.dilation, 2L);
			return torch.nn.functional.conv_transpose2d(input, base.weight, base.bias, base.stride, base.padding, array, base.dilation, base.groups);
		}
	}
	public sealed class ConvTranspose3d : ConvolutionTranspose
	{
		internal ConvTranspose3d(long in_channels, long out_channels, (long, long, long) kernel_size, (long, long, long) stride, (long, long, long) padding, (long, long, long) dilation, (long, long, long) output_padding, long groups = 1L, bool bias = true, PaddingModes padding_mode = PaddingModes.Zeros, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("ConvTranspose3d", in_channels, out_channels, new long[3] { kernel_size.Item1, kernel_size.Item2, kernel_size.Item3 }, new long[3] { stride.Item1, stride.Item2, stride.Item3 }, new long[3] { padding.Item1, padding.Item2, padding.Item3 }, null, new long[3] { dilation.Item1, dilation.Item2, dilation.Item3 }, transposed: true, new long[3] { output_padding.Item1, output_padding.Item2, output_padding.Item3 }, groups, bias, padding_mode, device, dtype)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, long[]? output_size)
		{
			if (!ValidateShape(input, 3L))
			{
				throw new ArgumentException($"Expected 4D (unbatched) or 5D (batched) input with {base.in_channels} channels to ConvTranspose3d.");
			}
			long[] array = _output_padding(input, output_size, base.kernel_size, base.stride, base.padding, base.dilation, 3L);
			return torch.nn.functional.conv_transpose3d(input, base.weight, base.bias, base.stride, base.padding, array, base.dilation, base.groups);
		}
	}
	public sealed class CosineSimilarity : ParameterLessModule<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public long dim { get; set; }

		public double eps { get; set; }

		internal CosineSimilarity(long dim = 1L, double eps = 1E-08)
			: base("CosineSimilarity")
		{
			this.dim = dim;
			this.eps = eps;
		}

		public override torch.Tensor forward(torch.Tensor input1, torch.Tensor input2)
		{
			return torch.nn.functional.cosine_similarity(input1, input2, dim, eps);
		}
	}
	public sealed class Dropout : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double p { get; set; }

		internal Dropout(double p = 0.5, bool inplace = false)
			: base("Dropout")
		{
			this.p = p;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.dropout(tensor, p, training, inplace);
		}
	}
	public sealed class Dropout1d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double p { get; set; }

		internal Dropout1d(double p = 0.5, bool inplace = false)
			: base("Dropout1d")
		{
			this.p = p;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			if (tensor.ndim != 3)
			{
				throw new ArgumentException("tensor passed to Dropout1d must be of the shape (N,C,L");
			}
			return torch.nn.functional.dropout1d(tensor, p, training, inplace);
		}
	}
	public sealed class Dropout2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double p { get; set; }

		internal Dropout2d(double p = 0.5, bool inplace = false)
			: base("Dropout2d")
		{
			this.p = p;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.dropout2d(input, p, training, inplace);
		}
	}
	public sealed class Dropout3d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double p { get; set; }

		internal Dropout3d(double p = 0.5, bool inplace = false)
			: base("Dropout3d")
		{
			this.p = p;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.dropout3d(input, p, training, inplace);
		}
	}
	public sealed class Embedding : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		public Parameter? weight
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_Embedding_weight(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight cannot be set to 'null'");
				}
				NativeMethods.THSNN_Embedding_set_weight(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight", value);
			}
		}

		internal Embedding(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			IntPtr intPtr = NativeMethods.THSNN_Embedding_forward(handle, input.Handle);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class EmbeddingBag : torch.nn.Module<torch.Tensor, torch.Tensor?, torch.Tensor?, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor?, torch.Tensor?, torch.Tensor>
	{
		public Parameter? weight
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_EmbeddingBag_weight(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight cannot be set to 'null'");
				}
				NativeMethods.THSNN_EmbeddingBag_set_weight(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight", value);
			}
		}

		internal EmbeddingBag(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor? offsets, torch.Tensor? perSampleWeights)
		{
			IntPtr intPtr = NativeMethods.THSNN_EmbeddingBag_forward(handle, input.Handle, offsets?.Handle ?? IntPtr.Zero, perSampleWeights?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public new torch.Tensor call(torch.Tensor input, torch.Tensor? offsets, torch.Tensor? perSampleWeights)
		{
			if (!input.IsIntegral())
			{
				throw new ArgumentException("Embedding input must be an integral tensor.");
			}
			if ((object)offsets != null && input.dtype != offsets.dtype)
			{
				throw new ArgumentException("input and offsets must have the same element type.");
			}
			if (input.Dimensions == 1 && (object)offsets == null)
			{
				throw new ArgumentException("'offsets' must be non-null for a 1-D input.");
			}
			if (input.Dimensions == 2 && (object)offsets != null)
			{
				throw new ArgumentException("'offsets' must be null for a 2-D input.");
			}
			if (input.Dimensions == 2 && input.dtype == torch.ScalarType.Int32)
			{
				throw new NotImplementedException("EmbeddingBag for 32-bit integers -- there's some issue in the native runtime that prevents this from working.");
			}
			return base.call(input, offsets, perSampleWeights);
		}

		public torch.Tensor call(torch.Tensor input, torch.Tensor offsets)
		{
			if (!input.IsIntegral())
			{
				throw new ArgumentException("Embedding input must be an integral tensor.");
			}
			if ((object)offsets != null && input.dtype != offsets.dtype)
			{
				throw new ArgumentException("input and offsets must have the same element type.");
			}
			if (input.Dimensions == 1 && (object)offsets == null)
			{
				throw new ArgumentException("'offsets' must be non-null for a 1-D input.");
			}
			if (input.Dimensions == 2 && (object)offsets != null)
			{
				throw new ArgumentException("'offsets' must be null for a 2-D input.");
			}
			if (input.Dimensions == 2 && input.dtype == torch.ScalarType.Int32)
			{
				throw new NotImplementedException("EmbeddingBag for 32-bit integers -- there's some issue in the native runtime that prevents this from working.");
			}
			return base.call(input, offsets, (torch.Tensor)null);
		}

		public torch.Tensor call(torch.Tensor input)
		{
			if (!input.IsIntegral())
			{
				throw new ArgumentException("Embedding input must be an integral tensor.");
			}
			if (input.Dimensions == 1)
			{
				throw new ArgumentException("'offsets' must be non-null for a 1-D input.");
			}
			if (input.Dimensions == 2 && input.dtype == torch.ScalarType.Int32)
			{
				throw new NotImplementedException("EmbeddingBag for 32-bit integers -- there's some issue in the native runtime that prevents this from working.");
			}
			return base.call(input, (torch.Tensor)null, (torch.Tensor)null);
		}
	}
	public sealed class FeatureAlphaDropout : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public bool inplace { get; set; }

		public double p { get; set; }

		internal FeatureAlphaDropout(double p = 0.5, bool inplace = false)
			: base("FeatureAlphaDropout")
		{
			this.p = p;
			this.inplace = inplace;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.feature_alpha_dropout(input, p, training, inplace);
		}
	}
	public sealed class Flatten : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long start_dim { get; set; }

		public long end_dim { get; set; }

		internal Flatten(long start_dim = 1L, long end_dim = -1L)
			: base("Flatten")
		{
			this.start_dim = start_dim;
			this.end_dim = end_dim;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return input.flatten(start_dim, end_dim);
		}
	}
	public sealed class Fold : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public (long, long) output_size { get; set; }

		public (long, long) kernel_size { get; set; }

		public (long, long) dilation { get; set; }

		public (long, long) padding { get; set; }

		public (long, long) stride { get; set; }

		internal Fold((long, long) output_size, (long, long) kernel_size, (long, long) dilation, (long, long) padding, (long, long) stride)
			: base("Fold")
		{
			this.output_size = output_size;
			this.kernel_size = kernel_size;
			this.dilation = dilation;
			this.padding = padding;
			this.stride = stride;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.fold(tensor, output_size, kernel_size, dilation, padding, stride);
		}
	}
	public abstract class Sequential<T, TResult> : torch.nn.Module<T, TResult>
	{
		private List<torch.nn.Module> _modules = new List<torch.nn.Module>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.Module this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential<T, TResult> this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential<T, TResult> append(string name, torch.nn.Module module)
		{
			Add(name, module);
			return this;
		}

		protected internal void Add(string name, torch.nn.Module sm)
		{
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential<T, TResult> append(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		protected internal void Add(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in _modules[i].named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in _modules[i].named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = _modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential()
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
		}

		protected Sequential(params (string name, torch.nn.Module submodule)[] modules)
			: this()
		{
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module[] modules)
			: this()
		{
			foreach (torch.nn.Module module in modules)
			{
				Add(module);
			}
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		protected virtual Sequential<T, TResult> Slice(int start, int end)
		{
			throw new NotImplementedException();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public abstract class Sequential<T1, T2, TResult> : torch.nn.Module<T1, T2, TResult>
	{
		private List<torch.nn.Module> _modules = new List<torch.nn.Module>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.Module this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential<T1, T2, TResult> this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential<T1, T2, TResult> append(string name, torch.nn.Module module)
		{
			Add(name, module);
			return this;
		}

		protected internal void Add(string name, torch.nn.Module sm)
		{
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential<T1, T2, TResult> append(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		protected internal void Add(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in _modules[i].named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in _modules[i].named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = _modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential()
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
		}

		protected Sequential(params (string name, torch.nn.Module submodule)[] modules)
			: this()
		{
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module[] modules)
			: this()
		{
			foreach (torch.nn.Module module in modules)
			{
				Add(module);
			}
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		protected virtual Sequential<T1, T2, TResult> Slice(int start, int end)
		{
			throw new NotImplementedException();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public abstract class Sequential<T1, T2, T3, TResult> : torch.nn.Module<T1, T2, T3, TResult>
	{
		private List<torch.nn.Module> _modules = new List<torch.nn.Module>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.Module this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential<T1, T2, T3, TResult> this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential<T1, T2, T3, TResult> append(string name, torch.nn.Module module)
		{
			Add(name, module);
			return this;
		}

		protected internal void Add(string name, torch.nn.Module sm)
		{
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential<T1, T2, T3, TResult> append(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		protected internal void Add(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in _modules[i].named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in _modules[i].named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = _modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential()
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
		}

		protected Sequential(params (string name, torch.nn.Module submodule)[] modules)
			: this()
		{
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module[] modules)
			: this()
		{
			foreach (torch.nn.Module module in modules)
			{
				Add(module);
			}
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		protected virtual Sequential<T1, T2, T3, TResult> Slice(int start, int end)
		{
			throw new NotImplementedException();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public abstract class Sequential<T1, T2, T3, T4, TResult> : torch.nn.Module<T1, T2, T3, T4, TResult>
	{
		private List<torch.nn.Module> _modules = new List<torch.nn.Module>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.Module this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential<T1, T2, T3, T4, TResult> this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential<T1, T2, T3, T4, TResult> append(string name, torch.nn.Module module)
		{
			Add(name, module);
			return this;
		}

		protected internal void Add(string name, torch.nn.Module sm)
		{
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential<T1, T2, T3, T4, TResult> append(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		protected internal void Add(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in _modules[i].named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in _modules[i].named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = _modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential()
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
		}

		protected Sequential(params (string name, torch.nn.Module submodule)[] modules)
			: this()
		{
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module[] modules)
			: this()
		{
			foreach (torch.nn.Module module in modules)
			{
				Add(module);
			}
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		protected virtual Sequential<T1, T2, T3, T4, TResult> Slice(int start, int end)
		{
			throw new NotImplementedException();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public abstract class Sequential<T1, T2, T3, T4, T5, TResult> : torch.nn.Module<T1, T2, T3, T4, T5, TResult>
	{
		private List<torch.nn.Module> _modules = new List<torch.nn.Module>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.Module this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential<T1, T2, T3, T4, T5, TResult> this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential<T1, T2, T3, T4, T5, TResult> append(string name, torch.nn.Module module)
		{
			Add(name, module);
			return this;
		}

		protected internal void Add(string name, torch.nn.Module sm)
		{
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential<T1, T2, T3, T4, T5, TResult> append(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		protected internal void Add(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in _modules[i].named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in _modules[i].named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = _modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential()
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
		}

		protected Sequential(params (string name, torch.nn.Module submodule)[] modules)
			: this()
		{
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module[] modules)
			: this()
		{
			foreach (torch.nn.Module module in modules)
			{
				Add(module);
			}
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		protected virtual Sequential<T1, T2, T3, T4, T5, TResult> Slice(int start, int end)
		{
			throw new NotImplementedException();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public abstract class Sequential<T1, T2, T3, T4, T5, T6, TResult> : torch.nn.Module<T1, T2, T3, T4, T5, T6, TResult>
	{
		private List<torch.nn.Module> _modules = new List<torch.nn.Module>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.Module this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential<T1, T2, T3, T4, T5, T6, TResult> this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential<T1, T2, T3, T4, T5, T6, TResult> append(string name, torch.nn.Module module)
		{
			Add(name, module);
			return this;
		}

		protected internal void Add(string name, torch.nn.Module sm)
		{
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential<T1, T2, T3, T4, T5, T6, TResult> append(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		protected internal void Add(torch.nn.Module module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in _modules[i].named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in _modules[i].named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: _modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = _modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential()
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
		}

		protected Sequential(params (string name, torch.nn.Module submodule)[] modules)
			: this()
		{
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module[] modules)
			: this()
		{
			foreach (torch.nn.Module module in modules)
			{
				Add(module);
			}
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		protected virtual Sequential<T1, T2, T3, T4, T5, T6, TResult> Slice(int start, int end)
		{
			throw new NotImplementedException();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public sealed class Identity : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		internal Identity()
			: base("Identity")
		{
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return tensor.alias();
		}
	}
	public sealed class Linear : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		private const string WeightComponentName = "weight";

		private const string BiasComponentName = "bias";

		[ComponentName(Name = "bias")]
		private Parameter? _bias;

		[ComponentName(Name = "weight")]
		private Parameter? _weight;

		private static readonly double _sqrt5 = Math.Sqrt(5.0);

		public Parameter? bias
		{
			get
			{
				return _bias;
			}
			set
			{
				_bias?.Dispose();
				_bias = value?.DetachFromDisposeScope() as Parameter;
				ConditionallyRegisterParameter("bias", _bias);
			}
		}

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public long in_features { get; set; }

		public long out_features { get; set; }

		internal Linear(Parameter weight, Parameter? bias = null)
			: base("Linear")
		{
			in_features = weight.shape[1];
			out_features = weight.shape[0];
			this.weight = weight;
			if ((object)bias != null)
			{
				this.bias = bias;
			}
		}

		internal Linear(long inputSize, long outputSize, bool hasBias = true, torch.Device? device = null, torch.ScalarType? dtype = null)
			: base("Linear")
		{
			in_features = inputSize;
			out_features = outputSize;
			torch.Device device2 = device;
			weight = torch.empty(outputSize, inputSize, dtype, device2).AsParameter();
			torch.nn.init.kaiming_uniform_(weight, _sqrt5);
			if (hasBias)
			{
				device2 = device;
				bias = torch.empty(outputSize, dtype, device2).AsParameter();
				long item = torch.nn.init.CalculateFanInAndFanOut(weight).fanIn;
				double num = ((item > 0) ? (1.0 / Math.Sqrt(item)) : 0.0);
				torch.nn.init.uniform_(_bias, 0.0 - num, num);
			}
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.linear(tensor, _weight, _bias);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				_weight?.Dispose();
				_bias?.Dispose();
			}
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			torch.Device device = new torch.Device(deviceType, deviceIndex);
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(_weight.dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(_bias.dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, _weight.device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, _bias.device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}
	}
	public sealed class CrossEntropyLoss : WeightedLoss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public long? ignore_index { get; }

		public double label_smoothing { get; }

		public CrossEntropyLoss(torch.Tensor? weight = null, long? ignore_index = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean, double label_smoothing = 0.0)
			: base(weight, reduction)
		{
			this.ignore_index = ignore_index;
			this.label_smoothing = label_smoothing;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			long num = (ignore_index.HasValue ? ignore_index.Value : (-100));
			IntPtr intPtr = NativeMethods.THSNN_cross_entropy(input.Handle, target.Handle, base.weight?.Handle ?? IntPtr.Zero, num, ignore_index.HasValue, (long)base.reduction, label_smoothing);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class BCELoss : WeightedLoss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public BCELoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(weight, reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_binary_cross_entropy(input.Handle, target.Handle, base.weight?.Handle ?? IntPtr.Zero, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class BCEWithLogitsLoss : WeightedLoss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public torch.Tensor? pos_weights { get; }

		public BCEWithLogitsLoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean, torch.Tensor? pos_weights = null)
			: base(weight, reduction)
		{
			this.pos_weights = pos_weights;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_binary_cross_entropy_with_logits(input.Handle, target.Handle, base.weight?.Handle ?? IntPtr.Zero, (long)base.reduction, pos_weights?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class CosineEmbeddingLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double margin { get; }

		public CosineEmbeddingLoss(double margin = 0.0, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.margin = margin;
		}

		public override torch.Tensor forward(torch.Tensor input1, torch.Tensor input2, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_cosine_embedding_loss(input1.Handle, input2.Handle, target.Handle, margin, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class CTCLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public long blank { get; }

		public bool zero_infinity { get; }

		public CTCLoss(long blank = 0L, bool zero_infinity = false, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.blank = blank;
			this.zero_infinity = zero_infinity;
		}

		public override torch.Tensor forward(torch.Tensor log_probs, torch.Tensor targets, torch.Tensor input_lengths, torch.Tensor target_lengths)
		{
			IntPtr intPtr = NativeMethods.THSNN_ctc_loss(log_probs.Handle, targets.Handle, input_lengths.Handle, target_lengths.Handle, blank, zero_infinity, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class HingeEmbeddingLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double margin { get; }

		public HingeEmbeddingLoss(double margin = 0.0, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.margin = margin;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_hinge_embedding_loss(input.Handle, target.Handle, margin, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class HuberLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double delta { get; }

		public HuberLoss(double delta = 1.0, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.delta = delta;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_huber_loss(input.Handle, target.Handle, delta, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class MarginRankingLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double margin { get; }

		public MarginRankingLoss(double margin = 0.0, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.margin = margin;
		}

		public override torch.Tensor forward(torch.Tensor input1, torch.Tensor input2, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_margin_ranking_loss(input1.Handle, input2.Handle, target.Handle, margin, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class MultiLabelMarginLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public MultiLabelMarginLoss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_multilabel_margin_loss(input.Handle, target.Handle, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class MultiLabelSoftMarginLoss : WeightedLoss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public MultiLabelSoftMarginLoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(weight, reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_multilabel_soft_margin_loss(input.Handle, target.Handle, base.weight?.Handle ?? IntPtr.Zero, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class MultiMarginLoss : WeightedLoss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double margin { get; }

		public int p { get; }

		public MultiMarginLoss(int p = 1, double margin = 1.0, torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(weight, reduction)
		{
			this.margin = margin;
			this.p = p;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = (((object)base.weight == null) ? IntPtr.Zero : base.weight.Handle);
			IntPtr intPtr2 = NativeMethods.THSNN_multi_margin_loss(input.Handle, target.Handle, p, margin, intPtr, (long)base.reduction);
			if (intPtr2 == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr2);
		}
	}
	public sealed class MSELoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public MSELoss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_mse_loss(input.Handle, target.Handle, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class L1Loss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public L1Loss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_l1_loss(input.Handle, target.Handle, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class NLLLoss : WeightedLoss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public NLLLoss(torch.Tensor? weight = null, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(weight, reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_nll_loss(input.Handle, target.Handle, base.weight?.Handle ?? IntPtr.Zero, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class PoissonNLLLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public bool log_input { get; }

		public bool full { get; }

		public float eps { get; }

		public PoissonNLLLoss(bool log_input = true, bool full = false, float eps = 1E-08f, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.full = full;
			this.log_input = log_input;
			this.eps = eps;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_poisson_loss(input.Handle, target.Handle, log_input, full, eps, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class GaussianNLLLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public bool full { get; }

		public float eps { get; }

		public GaussianNLLLoss(bool full = false, float eps = 1E-08f, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.full = full;
			this.eps = eps;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target, torch.Tensor variance)
		{
			input = input.view(input.shape[0], -1L);
			target = target.view(target.shape[0], -1L);
			if (target.shape == input.shape)
			{
				throw new ArgumentException("input and target must have the same shape");
			}
			variance = variance.view(target.shape[0], -1L);
			if (variance.shape[1] != input.shape[1] && variance.shape[1] != 1)
			{
				throw new ArgumentException("variance has the wrong shape");
			}
			if ((variance < 0).any().cpu().item<bool>())
			{
				throw new ArgumentException("variance has negative entry/entries");
			}
			using (torch.no_grad())
			{
				variance = variance.clamp_min(eps);
			}
			torch.Tensor tensor = (variance.log() + (input - target).square() / variance).view(input.shape[0], -1L);
			Span<long> span = stackalloc long[1] { 1L };
			torch.Tensor tensor2 = 0.5 * tensor.sum(span);
			if (full)
			{
				tensor2 += 0.5 * (double)input.shape[1] * (double)MathF.Log((float)Math.PI * 2f);
			}
			if (base.reduction != torch.nn.Reduction.Mean)
			{
				if (base.reduction != torch.nn.Reduction.Sum)
				{
					return tensor2;
				}
				return tensor2.sum();
			}
			return tensor2.mean();
		}
	}
	public sealed class KLDivLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public bool log_target { get; }

		public KLDivLoss(bool log_target = true, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.log_target = log_target;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_kl_div_loss(input.Handle, target.Handle, (long)base.reduction, log_target);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class SmoothL1Loss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double beta { get; }

		public SmoothL1Loss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean, double beta = 1.0)
			: base(reduction)
		{
			this.beta = beta;
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_smooth_l1_loss(input.Handle, target.Handle, (long)base.reduction, beta);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class SoftMarginLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public SoftMarginLoss(torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor target)
		{
			IntPtr intPtr = NativeMethods.THSNN_soft_margin_loss(input.Handle, target.Handle, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class TripletMarginLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double margin { get; }

		public long p { get; }

		private double eps { get; }

		private bool swap { get; }

		public TripletMarginLoss(double margin = 1.0, long p = 2L, double eps = 1E-06, bool swap = false, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			this.margin = margin;
			this.p = p;
			this.eps = eps;
			this.swap = swap;
		}

		public override torch.Tensor forward(torch.Tensor anchor, torch.Tensor positive, torch.Tensor negative)
		{
			IntPtr intPtr = NativeMethods.THSNN_triplet_margin_loss(anchor.Handle, positive.Handle, negative.Handle, margin, p, eps, swap, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class TripletMarginWithDistanceLoss : Loss<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		private DistanceFunctionNative? distance { get; }

		public double margin { get; }

		private bool swap { get; }

		public TripletMarginWithDistanceLoss(Func<torch.Tensor, torch.Tensor, torch.Tensor>? distance = null, double margin = 1.0, bool swap = false, torch.nn.Reduction reduction = torch.nn.Reduction.Mean)
			: base(reduction)
		{
			if (distance != null)
			{
				this.distance = delegate(IntPtr x, IntPtr y)
				{
					torch.Tensor tensor = new torch.Tensor(x);
					torch.Tensor tensor2 = new torch.Tensor(y);
					torch.Tensor tensor3 = distance(tensor, tensor2);
					GC.SuppressFinalize(tensor);
					GC.SuppressFinalize(tensor2);
					GC.SuppressFinalize(tensor3);
					return tensor3.Handle;
				};
			}
			this.margin = margin;
			this.swap = swap;
		}

		public override torch.Tensor forward(torch.Tensor anchor, torch.Tensor positive, torch.Tensor negative)
		{
			IntPtr intPtr = NativeMethods.THSNN_triplet_margin_with_distance_loss(anchor.Handle, positive.Handle, negative.Handle, distance, margin, swap, (long)base.reduction);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public class ModuleDict<T> : torch.nn.Module, IDictionary<string, T>, ICollection<KeyValuePair<string, T>>, IEnumerable<KeyValuePair<string, T>>, IEnumerable, IList<(string, T)>, ICollection<(string, T)>, IEnumerable<(string, T)> where T : torch.nn.Module
	{
		private bool _registered;

		private List<(string, T)> _list = new List<(string, T)>();

		private Dictionary<string, T> _dict = new Dictionary<string, T>();

		public (string, T) this[int index]
		{
			get
			{
				return _list[index];
			}
			set
			{
				var (key, _) = value;
				_list[index] = value;
				_dict[key] = value.Item2;
			}
		}

		public bool IsReadOnly => false;

		public ICollection<string> Keys => _list.Select(((string, T) kv) => kv.Item1).ToList();

		public ICollection<T> Values => _list.Select(((string, T) kv) => kv.Item2).ToList();

		public int Count => _dict.Count;

		public T this[string key]
		{
			get
			{
				return _dict[key];
			}
			set
			{
				_dict[key] = value;
				int index = _list.FindIndex(((string, T) kv) => kv.Item1.Equals(key));
				_list[index] = (key, value);
			}
		}

		public ModuleDict()
			: base("ModuleDict")
		{
		}

		public void clear()
		{
			_list.Clear();
			_dict.Clear();
		}

		public IEnumerator<(string, T)> items()
		{
			return _list.GetEnumerator();
		}

		public IEnumerable<string> keys()
		{
			return _dict.Keys;
		}

		protected override void RegisterComponents()
		{
			if (!_registered)
			{
				for (int i = 0; i < _list.Count; i++)
				{
					register_module(_list[i].Item1 ?? "", _list[i].Item2);
				}
				_registered = true;
			}
		}

		public IEnumerable<T> values()
		{
			return _dict.Values;
		}

		public void Add((string, T) item)
		{
			_dict.Add(item.Item1, item.Item2);
			_list.Add(item);
		}

		public void Add(string key, T value)
		{
			_dict.Add(key, value);
			_list.Add((key, value));
		}

		public void Add(KeyValuePair<string, T> item)
		{
			_dict.Add(item.Key, item.Value);
			_list.Add((item.Key, item.Value));
		}

		public bool Contains((string, T) item)
		{
			return _list.Contains(item);
		}

		public void CopyTo((string, T)[] array, int arrayIndex)
		{
			_list.CopyTo(array, arrayIndex);
		}

		public int IndexOf((string, T) item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, (string, T) item)
		{
			_dict.Add(item.Item1, item.Item2);
			_list.Insert(index, item);
		}

		public bool Remove((string, T) item)
		{
			_dict.Remove(item.Item1);
			return _list.Remove(item);
		}

		public void RemoveAt(int index)
		{
			if (index >= _list.Count)
			{
				throw new IndexOutOfRangeException();
			}
			string item = _list[index].Item1;
			_list.RemoveAt(index);
			_dict.Remove(item);
		}

		public bool ContainsKey(string key)
		{
			return _dict.ContainsKey(key);
		}

		public bool Remove(string key)
		{
			T item = _dict[key];
			if (_dict.Remove(key))
			{
				return _list.Remove((key, item));
			}
			return false;
		}

		public bool TryGetValue(string key, [MaybeNullWhen(false)] out T value)
		{
			return _dict.TryGetValue(key, out value);
		}

		public void Clear()
		{
			_dict.Clear();
			_list.Clear();
		}

		public bool Contains(KeyValuePair<string, T> item)
		{
			return _dict.ContainsKey(item.Key);
		}

		public void CopyTo(KeyValuePair<string, T>[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		public bool Remove(KeyValuePair<string, T> item)
		{
			return _dict.Remove(item.Key);
		}

		public IEnumerator<(string, T)> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		IEnumerator<KeyValuePair<string, T>> IEnumerable<KeyValuePair<string, T>>.GetEnumerator()
		{
			throw new NotImplementedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<KeyValuePair<string, T>>)this).GetEnumerator();
		}
	}
	public class ModuleList<T> : torch.nn.Module, IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable where T : torch.nn.Module
	{
		private bool _registered;

		private List<T> _list = new List<T>();

		public T this[int index]
		{
			get
			{
				return _list[index];
			}
			set
			{
				_list[index] = value;
			}
		}

		public int Count => _list.Count;

		public bool IsReadOnly => false;

		public ModuleList(params T[] modules)
			: base("ModuleList")
		{
			if (modules != null && modules.Length != 0)
			{
				_list.AddRange(modules);
			}
		}

		protected override void RegisterComponents()
		{
			if (!_registered)
			{
				for (int i = 0; i < _list.Count; i++)
				{
					register_module($"{i}", _list[i]);
				}
				_registered = true;
			}
		}

		public void Add(T item)
		{
			_list.Add(item);
		}

		public void append(params T[] parameters)
		{
			if (parameters != null && parameters.Length != 0)
			{
				_list.AddRange(parameters);
			}
		}

		public void Clear()
		{
			_list.Clear();
		}

		public bool Contains(T item)
		{
			return _list.Contains(item);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			_list.CopyTo(array, arrayIndex);
		}

		public void extend(IEnumerable<T> modules)
		{
			_list.AddRange(modules);
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		public int IndexOf(T item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, T item)
		{
			_list.Insert(index, item);
		}

		public bool Remove(T item)
		{
			return _list.Remove(item);
		}

		public void RemoveAt(int index)
		{
			_list.RemoveAt(index);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public sealed class MultiheadAttention : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor?, bool, torch.Tensor?, Tuple<torch.Tensor, torch.Tensor>>
	{
		internal MultiheadAttention(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override Tuple<torch.Tensor, torch.Tensor> forward(torch.Tensor query, torch.Tensor key, torch.Tensor value, torch.Tensor? key_padding_mask, bool need_weights, torch.Tensor? attn_mask)
		{
			NativeMethods.THSNN_MultiheadAttention_forward(handle, query.Handle, key.Handle, value.Handle, key_padding_mask?.Handle ?? IntPtr.Zero, need_weights, attn_mask?.Handle ?? IntPtr.Zero, out var res, out var res2);
			if (res == IntPtr.Zero || (need_weights && res2 == IntPtr.Zero))
			{
				torch.CheckForErrors();
			}
			return System.Tuple.Create(new torch.Tensor(res), new torch.Tensor(res2));
		}

		public new Tuple<torch.Tensor, torch.Tensor> call(torch.Tensor query, torch.Tensor key, torch.Tensor value, torch.Tensor? key_padding_mask = null, bool need_weights = true, torch.Tensor? attn_mask = null)
		{
			return base.call(query, key, value, key_padding_mask, need_weights, attn_mask);
		}
	}
	public abstract class BatchNorm : NormBase
	{
		public BatchNorm(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype, string name)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, name)
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			ValidateInputDimensions(input);
			double num = ((!base.momentum.HasValue) ? 0.0 : base.momentum.Value);
			if (training && base.track_running_stats && (object)base.num_batches_tracked != null)
			{
				base.num_batches_tracked.add_(1);
				num = ((!base.momentum.HasValue) ? (1.0 / (double)base.num_batches_tracked) : base.momentum.Value);
			}
			bool flag = training || ((object)base.running_mean == null && (object)base.running_var == null);
			bool flag2 = !training || base.track_running_stats;
			return torch.nn.functional.batch_norm(input, flag2 ? base.running_mean : null, flag2 ? base.running_var : null, base.weight, base.bias, flag, num, base.eps);
		}
	}
	public sealed class BatchNorm1d : BatchNorm
	{
		internal BatchNorm1d(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, "BatchNorm1d")
		{
		}

		protected override void ValidateInputDimensions(torch.Tensor input)
		{
			if (input.ndim != 2 && input.ndim != 3)
			{
				throw new ArgumentException($"expected 2D or 3D input, but got {input.ndim}D input.");
			}
		}
	}
	public sealed class BatchNorm2d : BatchNorm
	{
		internal BatchNorm2d(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, "BatchNorm1d")
		{
		}

		protected override void ValidateInputDimensions(torch.Tensor input)
		{
			if (input.ndim != 4)
			{
				throw new ArgumentException($"expected 4D input, but got {input.ndim}D input.");
			}
		}
	}
	public sealed class BatchNorm3d : BatchNorm
	{
		internal BatchNorm3d(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, "BatchNorm1d")
		{
		}

		protected override void ValidateInputDimensions(torch.Tensor input)
		{
			if (input.ndim != 5)
			{
				throw new ArgumentException($"expected 4D input, but got {input.ndim}D input.");
			}
		}
	}
	public sealed class GroupNorm : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		[ComponentName(Name = "bias")]
		private Parameter? _bias;

		[ComponentName(Name = "weight")]
		private Parameter? _weight;

		public Parameter? bias
		{
			get
			{
				return _bias;
			}
			set
			{
				_bias?.Dispose();
				_bias = value?.DetachFromDisposeScope() as Parameter;
				ConditionallyRegisterParameter("bias", _bias);
			}
		}

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public long num_groups { get; set; }

		public double eps { get; set; }

		public bool affine { get; set; }

		internal GroupNorm(long num_groups, long num_channels, double eps, bool affine, torch.Device? device, torch.ScalarType? dtype)
			: base("GroupNorm")
		{
			this.eps = eps;
			this.affine = affine;
			this.num_groups = num_groups;
			if (affine)
			{
				weight = torch.nn.Parameter(torch.empty(num_channels, dtype, device));
				bias = torch.nn.Parameter(torch.empty(num_channels, dtype, device));
			}
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			if (tensor.Dimensions < 3)
			{
				throw new ArgumentException($"Invalid number of dimensions for GroupNorm argument: {tensor.Dimensions}");
			}
			return torch.nn.functional.group_norm(tensor, num_groups, weight, bias, eps);
		}

		protected override void Dispose(bool disposing)
		{
			_weight?.Dispose();
			_bias?.Dispose();
			base.Dispose(disposing);
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			torch.Device device = new torch.Device(deviceType, deviceIndex);
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(_weight.dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(_bias.dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, _weight.device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, _bias.device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}
	}
	public abstract class InstanceNorm : NormBase
	{
		public InstanceNorm(long num_features, double eps, double? momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype, string name)
			: base(num_features, eps, momentum ?? new double?(0.1), affine, track_running_stats, device, dtype, name)
		{
		}

		protected abstract long GetNumberOfBatchDimensions();

		public override torch.Tensor forward(torch.Tensor input)
		{
			ValidateInputDimensions(input);
			int num = (int)(input.ndim - GetNumberOfBatchDimensions());
			if (input.size(num) != base.num_features)
			{
				throw new ArgumentException($"expected input's size at dim={num} to match num_features ({base.num_features}), but got: {input.size(num)}.");
			}
			if (num == 0)
			{
				using (torch.Tensor input2 = input.unsqueeze(0L))
				{
					return ApplyInstanceNorm(input2).squeeze_(0L);
				}
			}
			return ApplyInstanceNorm(input);
		}

		private torch.Tensor ApplyInstanceNorm(torch.Tensor input)
		{
			return torch.nn.functional.instance_norm(input, base.running_mean, base.running_var, base.weight, base.bias, training || !base.track_running_stats, base.momentum.HasValue ? base.momentum.Value : 0.1, base.eps);
		}
	}
	public sealed class InstanceNorm1d : InstanceNorm
	{
		internal InstanceNorm1d(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, "InstanceNorm1d")
		{
		}

		protected override long GetNumberOfBatchDimensions()
		{
			return 2L;
		}

		protected override void ValidateInputDimensions(torch.Tensor input)
		{
			if (input.ndim != 2 && input.ndim != 3)
			{
				throw new ArgumentException($"expected 2D or 3D input, but got {input.ndim}D input.");
			}
		}
	}
	public sealed class InstanceNorm2d : InstanceNorm
	{
		internal InstanceNorm2d(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, "InstanceNorm1d")
		{
		}

		protected override long GetNumberOfBatchDimensions()
		{
			return 3L;
		}

		protected override void ValidateInputDimensions(torch.Tensor input)
		{
			if (input.ndim != 3 && input.ndim != 4)
			{
				throw new ArgumentException($"expected 3D or 4D input, but got {input.ndim}D input.");
			}
		}
	}
	public sealed class InstanceNorm3d : InstanceNorm
	{
		internal InstanceNorm3d(long num_features, double eps, double momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype)
			: base(num_features, eps, momentum, affine, track_running_stats, device, dtype, "InstanceNorm3d")
		{
		}

		protected override long GetNumberOfBatchDimensions()
		{
			return 4L;
		}

		protected override void ValidateInputDimensions(torch.Tensor input)
		{
			if (input.ndim != 4 && input.ndim != 5)
			{
				throw new ArgumentException($"expected 4D or 4D input, but got {input.ndim}D input.");
			}
		}
	}
	public sealed class LayerNorm : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		private const string WeightComponentName = "weight";

		private const string BiasComponentName = "bias";

		[ComponentName(Name = "bias")]
		private Parameter? _bias;

		[ComponentName(Name = "weight")]
		private Parameter? _weight;

		public Parameter? bias
		{
			get
			{
				return _bias;
			}
			set
			{
				_bias?.Dispose();
				_bias = value?.DetachFromDisposeScope() as Parameter;
				ConditionallyRegisterParameter("bias", _bias);
			}
		}

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public long[] normalized_shape { get; set; }

		public double eps { get; set; }

		public bool elementwise_affine { get; set; }

		internal LayerNorm(long[] normalized_shape, double eps, bool elementwise_affine, bool bias, torch.Device? device, torch.ScalarType? dtype)
			: base("LayerNorm")
		{
			this.normalized_shape = normalized_shape;
			this.eps = eps;
			this.elementwise_affine = elementwise_affine;
			if (elementwise_affine)
			{
				weight = torch.nn.Parameter(torch.empty(normalized_shape, dtype, device));
				if (bias)
				{
					this.bias = torch.nn.Parameter(torch.empty(normalized_shape, dtype, device));
				}
			}
			reset_parameters();
		}

		public void reset_parameters()
		{
			if (elementwise_affine)
			{
				torch.nn.init.ones_(weight);
			}
			if ((object)bias != null)
			{
				torch.nn.init.zeros_(bias);
			}
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.layer_norm(tensor, normalized_shape, weight, bias, eps);
		}

		protected override void Dispose(bool disposing)
		{
			_weight?.Dispose();
			_bias?.Dispose();
			base.Dispose(disposing);
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			torch.Device device = new torch.Device(deviceType, deviceIndex);
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(_weight.dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(_bias.dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, _weight.device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, _bias.device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			return this;
		}
	}
	public sealed class LocalResponseNorm : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long size { get; set; }

		public double alpha { get; set; }

		public double beta { get; set; }

		public double k { get; set; }

		internal LocalResponseNorm(long size, double alpha = 0.0001, double beta = 0.75, double k = 1.0)
			: base("LocalResponseNorm")
		{
			this.size = size;
			this.alpha = alpha;
			this.beta = beta;
			this.k = k;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.local_response_norm(input, size, alpha, beta, k);
		}
	}
	public abstract class NormBase : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		[ComponentName(Name = "bias")]
		private Parameter? _bias;

		[ComponentName(Name = "weight")]
		private Parameter? _weight;

		[ComponentName(Name = "running_mean")]
		private torch.Tensor? _running_mean;

		[ComponentName(Name = "running_var")]
		private torch.Tensor? _running_var;

		[ComponentName(Name = "num_batches_tracked")]
		private torch.Tensor? _num_batches_tracked;

		public Parameter? bias
		{
			get
			{
				return _bias;
			}
			set
			{
				_bias?.Dispose();
				_bias = value?.DetachFromDisposeScope() as Parameter;
				ConditionallyRegisterParameter("bias", _bias);
			}
		}

		public Parameter weight
		{
			get
			{
				return _weight;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight");
				}
				IntPtr value2 = value.Handle;
				IntPtr? obj = _weight?.Handle;
				if (value2 != obj)
				{
					_weight?.Dispose();
					_weight = value.DetachFromDisposeScope() as Parameter;
					ConditionallyRegisterParameter("weight", _weight);
				}
			}
		}

		public torch.Tensor? running_mean
		{
			get
			{
				return _running_mean;
			}
			set
			{
				_running_mean?.Dispose();
				_running_mean = value?.DetachFromDisposeScope();
				ConditionallyRegisterBuffer("running_mean", _running_mean);
			}
		}

		public torch.Tensor? running_var
		{
			get
			{
				return _running_var;
			}
			set
			{
				_running_var?.Dispose();
				_running_var = value?.DetachFromDisposeScope();
				ConditionallyRegisterBuffer("running_var", _running_var);
			}
		}

		public torch.Tensor? num_batches_tracked
		{
			get
			{
				return _num_batches_tracked;
			}
			set
			{
				_num_batches_tracked?.Dispose();
				_num_batches_tracked = value?.DetachFromDisposeScope();
				ConditionallyRegisterBuffer("num_batches_tracked", _num_batches_tracked);
			}
		}

		public long num_features { get; private set; }

		public double eps { get; set; }

		public double? momentum { get; set; }

		public bool affine { get; private set; }

		public bool track_running_stats { get; private set; }

		public NormBase(long num_features, double eps, double? momentum, bool affine, bool track_running_stats, torch.Device? device, torch.ScalarType? dtype, string name)
			: base(name)
		{
			this.num_features = num_features;
			this.eps = eps;
			this.momentum = momentum;
			this.affine = affine;
			this.track_running_stats = track_running_stats;
			if (affine)
			{
				weight = torch.nn.Parameter(torch.empty(num_features, dtype, device));
				bias = torch.nn.Parameter(torch.empty(num_features, dtype, device));
			}
			if (track_running_stats)
			{
				running_mean = torch.zeros(num_features, dtype, device);
				running_var = torch.ones(num_features, dtype, device);
				num_batches_tracked = torch.tensor(0L, dtype, device);
			}
			reset_parameters();
		}

		private void ResetRunningStats()
		{
			if (track_running_stats)
			{
				torch.nn.init.zeros_(_running_mean);
				torch.nn.init.ones_(_running_var);
				torch.nn.init.zeros_(_num_batches_tracked);
			}
		}

		public void reset_running_stats()
		{
			ResetRunningStats();
		}

		public void reset_parameters()
		{
			ResetRunningStats();
			if (affine)
			{
				torch.nn.init.ones_(_weight);
				torch.nn.init.zeros_(_bias);
			}
		}

		protected abstract void ValidateInputDimensions(torch.Tensor input);

		protected override void Dispose(bool disposing)
		{
			_weight?.Dispose();
			_bias?.Dispose();
			_running_mean?.Dispose();
			_running_var?.Dispose();
			_num_batches_tracked?.Dispose();
			base.Dispose(disposing);
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			if ((object)_running_mean != null && torch.nn.Module.ReplaceBuffer(dtype, device, _running_mean, out torch.Tensor result))
			{
				running_mean = result;
			}
			if ((object)_running_var != null && torch.nn.Module.ReplaceBuffer(dtype, device, _running_var, out torch.Tensor result2))
			{
				running_var = result2;
			}
			if ((object)_num_batches_tracked != null && torch.nn.Module.ReplaceBuffer(dtype, device, _num_batches_tracked, out torch.Tensor result3))
			{
				num_batches_tracked = result3;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			torch.Device device = new torch.Device(deviceType, deviceIndex);
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(_weight.dtype, device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(_bias.dtype, device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			if ((object)_running_mean != null && torch.nn.Module.ReplaceBuffer(_running_mean.dtype, device, _running_mean, out torch.Tensor result))
			{
				running_mean = result;
			}
			if ((object)_running_var != null && torch.nn.Module.ReplaceBuffer(_running_var.dtype, device, _running_var, out torch.Tensor result2))
			{
				running_var = result2;
			}
			if ((object)_num_batches_tracked != null && torch.nn.Module.ReplaceBuffer(_num_batches_tracked.dtype, device, _num_batches_tracked, out torch.Tensor result3))
			{
				num_batches_tracked = result3;
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			if ((object)_weight != null && torch.nn.Module.ReplaceParameter(dtype, _weight.device, _weight, out Parameter p))
			{
				weight = p;
			}
			if ((object)_bias != null && torch.nn.Module.ReplaceParameter(dtype, _bias.device, _bias, out Parameter p2))
			{
				bias = p2;
			}
			if ((object)_running_mean != null && torch.nn.Module.ReplaceBuffer(dtype, _running_mean.device, _running_mean, out torch.Tensor result))
			{
				running_mean = result;
			}
			if ((object)_running_var != null && torch.nn.Module.ReplaceBuffer(dtype, _running_var.device, _running_var, out torch.Tensor result2))
			{
				running_var = result2;
			}
			if ((object)_num_batches_tracked != null && torch.nn.Module.ReplaceBuffer(dtype, _num_batches_tracked.device, _num_batches_tracked, out torch.Tensor result3))
			{
				num_batches_tracked = result3;
			}
			return this;
		}
	}
	public sealed class ConstantPad1d : PadBase
	{
		internal ConstantPad1d(double value, params long[] padding)
			: base("ConstantPad1d", PaddingModes.Constant, value, padding)
		{
		}
	}
	public sealed class ConstantPad2d : PadBase
	{
		internal ConstantPad2d(double value, params long[] padding)
			: base("ConstantPad2d", PaddingModes.Constant, value, padding)
		{
		}
	}
	public sealed class ConstantPad3d : PadBase
	{
		internal ConstantPad3d(double value, params long[] padding)
			: base("ConstantPad3d", PaddingModes.Constant, value, padding)
		{
		}
	}
	public abstract class PadBase : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		private PaddingModes padding_mode { get; set; }

		public long[] padding { get; set; }

		public double value { get; set; }

		protected PadBase(string name, PaddingModes mode, double value, params long[] padding)
			: base(name)
		{
			this.value = value;
			this.padding = padding;
			padding_mode = mode;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.pad(input, padding, padding_mode, value);
		}
	}
	public sealed class ReflectionPad1d : PadBase
	{
		internal ReflectionPad1d(params long[] padding)
			: base("ReflectionPad1d", PaddingModes.Reflect, 0.0, padding)
		{
		}
	}
	public sealed class ReflectionPad2d : PadBase
	{
		internal ReflectionPad2d(params long[] padding)
			: base("ReflectionPad2d", PaddingModes.Reflect, 0.0, padding)
		{
		}
	}
	public sealed class ReflectionPad3d : PadBase
	{
		internal ReflectionPad3d(params long[] padding)
			: base("ReflectionPad3d", PaddingModes.Reflect, 0.0, padding)
		{
		}
	}
	public sealed class ReplicationPad1d : PadBase
	{
		internal ReplicationPad1d(params long[] padding)
			: base("ReplicationPad1d", PaddingModes.Replicate, 0.0, padding)
		{
		}
	}
	public sealed class ReplicationPad2d : PadBase
	{
		internal ReplicationPad2d(params long[] padding)
			: base("ReplicationPad2d", PaddingModes.Replicate, 0.0, padding)
		{
		}
	}
	public sealed class ReplicationPad3d : PadBase
	{
		internal ReplicationPad3d(params long[] padding)
			: base("ReplicationPad3d", PaddingModes.Replicate, 0.0, padding)
		{
		}
	}
	public sealed class ZeroPad2d : PadBase
	{
		internal ZeroPad2d(params long[] padding)
			: base("ZeroPad2d", PaddingModes.Zeros, 0.0, padding)
		{
		}
	}
	public sealed class PairwiseDistance : ParameterLessModule<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public double norm { get; set; }

		public double eps { get; set; }

		public bool keepdim { get; set; }

		internal PairwiseDistance(double p = 2.0, double eps = 1E-06, bool keepdim = false)
			: base("PairwiseDistance")
		{
			norm = p;
			this.eps = eps;
			this.keepdim = keepdim;
		}

		public override torch.Tensor forward(torch.Tensor input1, torch.Tensor input2)
		{
			return torch.nn.functional.pairwise_distance(input1, input2, norm, eps, keepdim);
		}
	}
	public class Parameter : torch.Tensor
	{
		public Parameter(torch.Tensor data, bool requires_grad = true)
			: base(data.with_requires_grad(requires_grad).MoveHandle(), register: false)
		{
			if (data.OwningDisposeScope != null)
			{
				DisposeScope.ReplaceWith(data, this);
			}
		}

		internal Parameter(IntPtr handle)
			: base(handle)
		{
		}
	}
	public class ParameterDict : torch.nn.Module, IDictionary<string, Parameter>, ICollection<KeyValuePair<string, Parameter>>, IEnumerable<KeyValuePair<string, Parameter>>, IEnumerable, IList<(string, Parameter)>, ICollection<(string, Parameter)>, IEnumerable<(string, Parameter)>
	{
		private bool _registered;

		private List<(string, Parameter)> _list = new List<(string, Parameter)>();

		private Dictionary<string, Parameter> _dict = new Dictionary<string, Parameter>();

		public (string, Parameter) this[int index]
		{
			get
			{
				return _list[index];
			}
			set
			{
				var (key, _) = value;
				_list[index] = value;
				_dict[key] = value.Item2;
			}
		}

		public bool IsReadOnly => false;

		public ICollection<string> Keys => _list.Select(((string, Parameter) kv) => kv.Item1).ToList();

		public ICollection<Parameter> Values => _list.Select(((string, Parameter) kv) => kv.Item2).ToList();

		public int Count => _dict.Count;

		public Parameter this[string key]
		{
			get
			{
				return _dict[key];
			}
			set
			{
				_dict[key] = value;
				int index = _list.FindIndex(((string, Parameter) kv) => kv.Item1.Equals(key));
				_list[index] = (key, value);
			}
		}

		public ParameterDict()
			: base("ParameterDict")
		{
		}

		public void clear()
		{
			_list.Clear();
			_dict.Clear();
		}

		public IEnumerator<(string, Parameter)> items()
		{
			return _list.GetEnumerator();
		}

		public IEnumerable<string> keys()
		{
			return _dict.Keys;
		}

		protected override void RegisterComponents()
		{
			if (!_registered)
			{
				for (int i = 0; i < _list.Count; i++)
				{
					register_parameter(_list[i].Item1 ?? "", _list[i].Item2);
				}
				_registered = true;
			}
		}

		protected override void _toEpilog(torch.ScalarType? dtype, torch.Device device, bool non_blocking)
		{
			for (int i = 0; i < _list.Count; i++)
			{
				string item = _list[i].Item1;
				Parameter item2 = _list[i].Item2;
				using torch.Tensor tensor = item2.grad;
				if (!item2.toWillCopy(dtype ?? item2.dtype, device ?? item2.device) && ((object)tensor == null || !tensor.toWillCopy(dtype ?? item2.dtype, device ?? item2.device)))
				{
					continue;
				}
				torch.ScalarType type = ((dtype.HasValue && (item2.dtype.IsFloatingPoint() || item2.dtype.IsComplex())) ? dtype.Value : item2.dtype);
				Parameter parameter;
				using (torch.no_grad())
				{
					parameter = new Parameter(item2.to(type, device ?? item2.device), item2.requires_grad);
					parameter.DetachFromDisposeScope();
					if ((object)tensor != null)
					{
						using torch.Tensor grad = tensor.to(type, device ?? item2.device).with_requires_grad(tensor.requires_grad);
						parameter.grad = grad;
					}
				}
				item2?.Dispose();
				_list[i] = (item, parameter);
				_dict[item] = parameter;
			}
			if (device != null)
			{
				_deviceType = device.type;
				_deviceIndex = device.index;
			}
		}

		public IEnumerable<Parameter> values()
		{
			return _dict.Values;
		}

		public override bool has_parameter(string target)
		{
			return _dict.ContainsKey(target);
		}

		public override Parameter get_parameter(string target)
		{
			if (_dict.TryGetValue(target, out var value))
			{
				return value;
			}
			return null;
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse)
		{
			return _dict.Select((KeyValuePair<string, Parameter> d) => (Key: d.Key, Value: d.Value));
		}

		public void Add((string, Parameter) item)
		{
			_dict.Add(item.Item1, item.Item2);
			_list.Add(item);
		}

		public void Add(string key, Parameter value)
		{
			_dict.Add(key, value);
			_list.Add((key, value));
		}

		public void Add(KeyValuePair<string, Parameter> item)
		{
			_dict.Add(item.Key, item.Value);
			_list.Add((item.Key, item.Value));
		}

		public bool Contains((string, Parameter) item)
		{
			return _list.Contains(item);
		}

		public void CopyTo((string, Parameter)[] array, int arrayIndex)
		{
			_list.CopyTo(array, arrayIndex);
		}

		public int IndexOf((string, Parameter) item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, (string, Parameter) item)
		{
			_dict.Add(item.Item1, item.Item2);
			_list.Insert(index, item);
		}

		public bool Remove((string, Parameter) item)
		{
			_dict.Remove(item.Item1);
			return _list.Remove(item);
		}

		public void RemoveAt(int index)
		{
			if (index >= _list.Count)
			{
				throw new IndexOutOfRangeException();
			}
			string item = _list[index].Item1;
			_list.RemoveAt(index);
			_dict.Remove(item);
		}

		public bool ContainsKey(string key)
		{
			return _dict.ContainsKey(key);
		}

		public bool Remove(string key)
		{
			_ = _dict[key];
			int index = _list.FindIndex(((string, Parameter) kv) => kv.Item1.Equals(key));
			_list.RemoveAt(index);
			return _dict.Remove(key);
		}

		public bool TryGetValue(string key, [MaybeNullWhen(false)] out Parameter value)
		{
			return _dict.TryGetValue(key, out value);
		}

		public void Clear()
		{
			_dict.Clear();
			_list.Clear();
		}

		public bool Contains(KeyValuePair<string, Parameter> item)
		{
			return _dict.ContainsKey(item.Key);
		}

		public void CopyTo(KeyValuePair<string, Parameter>[] array, int arrayIndex)
		{
			throw new NotImplementedException();
		}

		public bool Remove(KeyValuePair<string, Parameter> item)
		{
			return _dict.Remove(item.Key);
		}

		public IEnumerator<(string, Parameter)> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		IEnumerator<KeyValuePair<string, Parameter>> IEnumerable<KeyValuePair<string, Parameter>>.GetEnumerator()
		{
			throw new NotImplementedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return ((IEnumerable<KeyValuePair<string, Parameter>>)this).GetEnumerator();
		}
	}
	public class ParameterList : torch.nn.Module, IList<Parameter>, ICollection<Parameter>, IEnumerable<Parameter>, IEnumerable
	{
		private bool _registered;

		private List<Parameter> _list = new List<Parameter>();

		public Parameter this[int index]
		{
			get
			{
				return _list[index];
			}
			set
			{
				_list[index] = value;
			}
		}

		public int Count => _list.Count;

		public bool IsReadOnly => false;

		public ParameterList(params Parameter[] parameters)
			: base("ParameterList")
		{
			if (parameters != null && parameters.Length != 0)
			{
				_list.AddRange(parameters);
			}
		}

		protected override void RegisterComponents()
		{
			if (!_registered)
			{
				for (int i = 0; i < _list.Count; i++)
				{
					register_parameter($"{i}", _list[i]);
				}
				_registered = true;
			}
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			return from i in Enumerable.Range(0, _list.Count)
				select ($"{i}", _list[i]);
		}

		public override bool has_parameter(string target)
		{
			if (int.TryParse(target, out var result) && result > -1 && result < _list.Count)
			{
				return (object)_list[result] != null;
			}
			return false;
		}

		public override Parameter? get_parameter(string target)
		{
			if (int.TryParse(target, out var result) && result > -1 && result < _list.Count)
			{
				return _list[result];
			}
			return null;
		}

		protected override void _toEpilog(torch.ScalarType? dtype, torch.Device? device, bool non_blocking)
		{
			for (int i = 0; i < _list.Count; i++)
			{
				_ = $"{i}";
				Parameter parameter = _list[i];
				using torch.Tensor tensor = parameter.grad;
				if (!parameter.toWillCopy(dtype ?? parameter.dtype, device ?? parameter.device) && ((object)tensor == null || !tensor.toWillCopy(dtype ?? parameter.dtype, device ?? parameter.device)))
				{
					continue;
				}
				torch.ScalarType type = ((dtype.HasValue && (parameter.dtype.IsFloatingPoint() || parameter.dtype.IsComplex())) ? dtype.Value : parameter.dtype);
				Parameter parameter2;
				using (torch.no_grad())
				{
					parameter2 = new Parameter(parameter.to(type, device ?? parameter.device), parameter.requires_grad);
					parameter2.DetachFromDisposeScope();
					if ((object)tensor != null)
					{
						using torch.Tensor grad = tensor.to(type, device ?? parameter.device).with_requires_grad(tensor.requires_grad);
						parameter2.grad = grad;
					}
				}
				parameter?.Dispose();
				_list[i] = parameter2;
			}
			if (device != null)
			{
				_deviceType = device.type;
				_deviceIndex = device.index;
			}
		}

		public void Add(Parameter item)
		{
			_list.Add(item);
		}

		public void extend(IEnumerable<Parameter> parameters)
		{
			_list.AddRange(parameters);
		}

		public void append(params Parameter[] parameters)
		{
			if (parameters != null && parameters.Length != 0)
			{
				_list.AddRange(parameters);
			}
		}

		public void Clear()
		{
			_list.Clear();
		}

		public bool Contains(Parameter item)
		{
			return _list.Contains(item);
		}

		public void CopyTo(Parameter[] array, int arrayIndex)
		{
			_list.CopyTo(array, arrayIndex);
		}

		public IEnumerator<Parameter> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		public int IndexOf(Parameter item)
		{
			return _list.IndexOf(item);
		}

		public void Insert(int index, Parameter item)
		{
			_list.Insert(index, item);
		}

		public bool Remove(Parameter item)
		{
			return _list.Remove(item);
		}

		public void RemoveAt(int index)
		{
			_list.RemoveAt(index);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public interface IParameterLessModule
	{
	}
	public abstract class ParameterLessModule<T1, TResult> : torch.nn.Module<T1, TResult>, IParameterLessModule
	{
		protected ParameterLessModule(string name)
			: base(name)
		{
		}

		protected ParameterLessModule(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		public override void register_buffer(string name, torch.Tensor tensor, bool persistent = true)
		{
			throw new InvalidOperationException("Cannot register a buffer on a module that is declared 'parameter-less.'");
		}

		public override void register_parameter(string name, Parameter param)
		{
			throw new InvalidOperationException("Cannot register a parameter on a module that is declared 'parameter-less.'");
		}

		public override void register_module(string name, torch.nn.Module submodule)
		{
			if (!(submodule is IParameterLessModule))
			{
				throw new InvalidOperationException("Submodules of a parameter-less module must also be parameter-less.");
			}
			base.register_module(name, submodule);
		}
	}
	public abstract class ParameterLessModule<T1, T2, TResult> : torch.nn.Module<T1, T2, TResult>, IParameterLessModule
	{
		protected ParameterLessModule(string name)
			: base(name)
		{
		}

		protected ParameterLessModule(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		public override void register_buffer(string name, torch.Tensor tensor, bool persistent = true)
		{
			throw new InvalidOperationException("Cannot register a buffer on a module that is declared 'parameter-less.'");
		}

		public override void register_parameter(string name, Parameter param)
		{
			throw new InvalidOperationException("Cannot register a parameter on a module that is declared 'parameter-less.'");
		}

		public override void register_module(string name, torch.nn.Module submodule)
		{
			if (!(submodule is IParameterLessModule))
			{
				throw new InvalidOperationException("Submodules of a parameter-less module must also be parameter-less.");
			}
			base.register_module(name, submodule);
		}
	}
	public abstract class ParameterLessModule<T1, T2, T3, TResult> : torch.nn.Module<T1, T2, T3, TResult>, IParameterLessModule
	{
		protected ParameterLessModule(string name)
			: base(name)
		{
		}

		protected ParameterLessModule(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		public override void register_buffer(string name, torch.Tensor tensor, bool persistent = true)
		{
			throw new InvalidOperationException("Cannot register a buffer on a module that is declared 'parameter-less.'");
		}

		public override void register_parameter(string name, Parameter param)
		{
			throw new InvalidOperationException("Cannot register a parameter on a module that is declared 'parameter-less.'");
		}

		public override void register_module(string name, torch.nn.Module submodule)
		{
			if (!(submodule is IParameterLessModule))
			{
				throw new InvalidOperationException("Submodules of a parameter-less module must also be parameter-less.");
			}
			base.register_module(name, submodule);
		}
	}
	public abstract class ParameterLessModule<T1, T2, T3, T4, TResult> : torch.nn.Module<T1, T2, T3, T4, TResult>, IParameterLessModule
	{
		protected ParameterLessModule(string name)
			: base(name)
		{
		}

		protected ParameterLessModule(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		public override void register_buffer(string name, torch.Tensor tensor, bool persistent = true)
		{
			throw new InvalidOperationException("Cannot register a buffer on a module that is declared 'parameter-less.'");
		}

		public override void register_parameter(string name, Parameter param)
		{
			throw new InvalidOperationException("Cannot register a parameter on a module that is declared 'parameter-less.'");
		}

		public override void register_module(string name, torch.nn.Module submodule)
		{
			if (!(submodule is IParameterLessModule))
			{
				throw new InvalidOperationException("Submodules of a parameter-less module must also be parameter-less.");
			}
			base.register_module(name, submodule);
		}
	}
	public abstract class ParameterLessModule<T1, T2, T3, T4, T5, TResult> : torch.nn.Module<T1, T2, T3, T4, T5, TResult>, IParameterLessModule
	{
		protected ParameterLessModule(string name)
			: base(name)
		{
		}

		protected ParameterLessModule(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		public override void register_buffer(string name, torch.Tensor tensor, bool persistent = true)
		{
			throw new InvalidOperationException("Cannot register a buffer on a module that is declared 'parameter-less.'");
		}

		public override void register_parameter(string name, Parameter param)
		{
			throw new InvalidOperationException("Cannot register a parameter on a module that is declared 'parameter-less.'");
		}

		public override void register_module(string name, torch.nn.Module submodule)
		{
			if (!(submodule is IParameterLessModule))
			{
				throw new InvalidOperationException("Submodules of a parameter-less module must also be parameter-less.");
			}
			base.register_module(name, submodule);
		}
	}
	public abstract class ParameterLessModule<T1, T2, T3, T4, T5, T6, TResult> : torch.nn.Module<T1, T2, T3, T4, T5, T6, TResult>, IParameterLessModule
	{
		protected ParameterLessModule(string name)
			: base(name)
		{
		}

		protected ParameterLessModule(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			return this;
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			return this;
		}

		public override void register_buffer(string name, torch.Tensor tensor, bool persistent = true)
		{
			throw new InvalidOperationException("Cannot register a buffer on a module that is declared 'parameter-less.'");
		}

		public override void register_parameter(string name, Parameter param)
		{
			throw new InvalidOperationException("Cannot register a parameter on a module that is declared 'parameter-less.'");
		}

		public override void register_module(string name, torch.nn.Module submodule)
		{
			if (!(submodule is IParameterLessModule))
			{
				throw new InvalidOperationException("Submodules of a parameter-less module must also be parameter-less.");
			}
			base.register_module(name, submodule);
		}
	}
	public sealed class PixelShuffle : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long upscale_factor { get; set; }

		internal PixelShuffle(long upscale_factor)
			: base("PixelShuffle")
		{
			this.upscale_factor = upscale_factor;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.pixel_shuffle(input, upscale_factor);
		}
	}
	public sealed class PixelUnshuffle : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long downscale_factor { get; set; }

		internal PixelUnshuffle(long downscale_factor)
			: base("PixelUnshuffle")
		{
			this.downscale_factor = downscale_factor;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.pixel_unshuffle(input, downscale_factor);
		}
	}
	public sealed class AdaptiveAvgPool1d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long output_size { get; set; }

		internal AdaptiveAvgPool1d(long output_size)
			: base("AdaptiveAvgPool1d")
		{
			this.output_size = output_size;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_avg_pool1d(input, output_size);
		}
	}
	public sealed class AdaptiveAvgPool2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] output_size { get; set; }

		internal AdaptiveAvgPool2d(long[] output_size)
			: base("AdaptiveAvgPool2d")
		{
			this.output_size = output_size;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_avg_pool2d(input, output_size);
		}
	}
	public sealed class AdaptiveAvgPool3d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] output_size { get; set; }

		internal AdaptiveAvgPool3d(long[] output_size)
			: base("AdaptiveAvgPool3d")
		{
			this.output_size = output_size;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_avg_pool3d(input, output_size);
		}
	}
	public sealed class AdaptiveMaxPool1d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long output_size { get; set; }

		internal AdaptiveMaxPool1d(long output_size)
			: base("AdaptiveMaxPool1d")
		{
			this.output_size = output_size;
		}

		public (torch.Tensor Values, torch.Tensor Indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_max_pool1d_with_indices(input, output_size);
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_max_pool1d(input, output_size);
		}
	}
	public sealed class AdaptiveMaxPool2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] output_size { get; set; }

		internal AdaptiveMaxPool2d(long[] output_size)
			: base("AdaptiveMaxPool2d")
		{
			this.output_size = output_size;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_max_pool2d(input, output_size);
		}

		public (torch.Tensor output, torch.Tensor indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_max_pool2d_with_indices(input, output_size);
		}
	}
	public sealed class AdaptiveMaxPool3d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] output_size { get; set; }

		internal AdaptiveMaxPool3d(long[] output_size)
			: base("AdaptiveMaxPool3d")
		{
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_max_pool3d(input, output_size);
		}

		public (torch.Tensor output, torch.Tensor indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.adaptive_max_pool3d_with_indices(input, output_size);
		}
	}
	public sealed class AvgPool1d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long kernel_size { get; set; }

		public long? stride { get; set; }

		public long? padding { get; set; }

		public bool ceil_mode { get; set; }

		public bool count_include_pad { get; set; }

		internal AvgPool1d(long kernel_size, long? stride = null, long? padding = null, bool ceil_mode = false, bool count_include_pad = true)
			: base("AvgPool1d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
			this.ceil_mode = ceil_mode;
			this.count_include_pad = count_include_pad;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.avg_pool1d(input, kernel_size, stride, padding, ceil_mode, count_include_pad);
		}
	}
	public sealed class AvgPool2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] padding { get; set; }

		public bool ceil_mode { get; set; }

		public bool count_include_pad { get; set; }

		public long? divisor_override { get; set; }

		internal AvgPool2d(long[] kernel_size, long[] stride = null, long[] padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			: base("AvgPool2d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
			this.ceil_mode = ceil_mode;
			this.count_include_pad = count_include_pad;
			this.divisor_override = divisor_override;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.avg_pool2d(input, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
		}
	}
	public sealed class AvgPool3d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] padding { get; set; }

		public bool ceil_mode { get; set; }

		public bool count_include_pad { get; set; }

		public long? divisor_override { get; set; }

		internal AvgPool3d(long[] kernel_size, long[] stride = null, long[] padding = null, bool ceil_mode = false, bool count_include_pad = true, long? divisor_override = null)
			: base("AvgPool3d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
			this.ceil_mode = ceil_mode;
			this.count_include_pad = count_include_pad;
			this.divisor_override = divisor_override;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.avg_pool3d(input, kernel_size, stride, padding, ceil_mode, count_include_pad, divisor_override);
		}
	}
	public sealed class FractionalMaxPool2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] output_size { get; set; }

		public double[] output_ratio { get; set; }

		internal FractionalMaxPool2d(long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
			: base("FractionalMaxPool2d")
		{
			this.kernel_size = kernel_size;
			this.output_size = output_size;
			this.output_ratio = output_ratio;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.fractional_max_pool2d(input, kernel_size, output_size, output_ratio);
		}

		public (torch.Tensor Values, torch.Tensor Indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.fractional_max_pool2d_with_indices(input, kernel_size, output_size, output_ratio);
		}
	}
	public sealed class FractionalMaxPool3d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] output_size { get; set; }

		public double[] output_ratio { get; set; }

		internal FractionalMaxPool3d(long[] kernel_size, long[] output_size = null, double[] output_ratio = null)
			: base("FractionalMaxPool3d")
		{
			this.kernel_size = kernel_size;
			this.output_size = output_size;
			this.output_ratio = output_ratio;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.fractional_max_pool3d(input, kernel_size, output_size, output_ratio);
		}

		public (torch.Tensor Values, torch.Tensor Indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.fractional_max_pool3d_with_indices(input, kernel_size, output_size, output_ratio);
		}
	}
	public sealed class LPPool1d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double norm_type { get; set; }

		public long kernel_size { get; set; }

		public long? stride { get; set; }

		public bool ceil_mode { get; set; }

		internal LPPool1d(double norm_type, long kernel_size, long? stride = null, bool ceil_mode = false)
			: base("LPPool1d")
		{
			this.norm_type = norm_type;
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.ceil_mode = ceil_mode;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.lp_pool1d(input, norm_type, kernel_size, stride, ceil_mode);
		}
	}
	public sealed class LPPool2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public double norm_type { get; set; }

		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public bool ceil_mode { get; set; }

		internal LPPool2d(double norm_type, long[] kernel_size, long[] stride = null, bool ceil_mode = false)
			: base("LPPool2d")
		{
			this.norm_type = norm_type;
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.ceil_mode = ceil_mode;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.lp_pool2d(input, norm_type, kernel_size, stride, ceil_mode);
		}
	}
	public sealed class MaxPool1d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long kernel_size { get; set; }

		public long? stride { get; set; }

		public long? padding { get; set; }

		public long? dilation { get; set; }

		public bool ceil_mode { get; set; }

		internal MaxPool1d(long kernel_size, long? stride = null, long? padding = null, long? dilation = null, bool ceil_mode = false)
			: base("MaxPool1d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
			this.dilation = dilation;
			this.ceil_mode = ceil_mode;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.max_pool1d(input, kernel_size, stride, padding, dilation, ceil_mode);
		}

		public (torch.Tensor Values, torch.Tensor Indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.max_pool1d_with_indices(input, kernel_size, stride, padding, dilation, ceil_mode);
		}
	}
	public sealed class MaxPool2d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] padding { get; set; }

		public long[] dilation { get; set; }

		public bool ceil_mode { get; set; }

		internal MaxPool2d(long[] kernel_size, long[] stride = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
			: base("MaxPool2d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
			this.dilation = dilation;
			this.ceil_mode = ceil_mode;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.max_pool2d(input, kernel_size, stride, padding, dilation, ceil_mode);
		}

		public (torch.Tensor Values, torch.Tensor Indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.max_pool2d_with_indices(input, kernel_size, stride, padding, dilation, ceil_mode);
		}
	}
	public sealed class MaxPool3d : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] padding { get; set; }

		public long[] dilation { get; set; }

		public bool ceil_mode { get; set; }

		internal MaxPool3d(long[] kernel_size, long[] stride = null, long[] padding = null, long[] dilation = null, bool ceil_mode = false)
			: base("MaxPool3d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
			this.dilation = dilation;
			this.ceil_mode = ceil_mode;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.max_pool3d(input, kernel_size, stride, padding, dilation, ceil_mode);
		}

		public (torch.Tensor Values, torch.Tensor Indices) forward_with_indices(torch.Tensor input)
		{
			return torch.nn.functional.max_pool3d_with_indices(input, kernel_size, stride, padding, dilation, ceil_mode);
		}
	}
	public sealed class MaxUnpool1d : ParameterLessModule<torch.Tensor, torch.Tensor, long[], torch.Tensor>
	{
		public long kernel_size { get; set; }

		public long? stride { get; set; }

		public long? padding { get; set; }

		internal MaxUnpool1d(long kernel_size, long? stride = null, long? padding = null)
			: base("MaxUnpool1d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
		}

		public override torch.Tensor forward(torch.Tensor tensor, torch.Tensor indices, long[] output_size = null)
		{
			return torch.nn.functional.max_unpool1d(tensor, indices, kernel_size, stride, padding, output_size);
		}

		public new torch.Tensor call(torch.Tensor tensor, torch.Tensor indices, long[] output_size = null)
		{
			return base.call(tensor, indices, output_size);
		}
	}
	public sealed class MaxUnpool2d : ParameterLessModule<torch.Tensor, torch.Tensor, long[], torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] padding { get; set; }

		internal MaxUnpool2d(long[] kernel_size, long[] stride = null, long[] padding = null)
			: base("MaxUnpool2d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
		}

		public override torch.Tensor forward(torch.Tensor tensor, torch.Tensor indices, long[] output_size = null)
		{
			return torch.nn.functional.max_unpool2d(tensor, indices, kernel_size, stride, padding, output_size);
		}

		public new torch.Tensor call(torch.Tensor tensor, torch.Tensor indices, long[] output_size = null)
		{
			return base.call(tensor, indices, output_size);
		}
	}
	public sealed class MaxUnpool3d : ParameterLessModule<torch.Tensor, torch.Tensor, long[], torch.Tensor>
	{
		public long[] kernel_size { get; set; }

		public long[] stride { get; set; }

		public long[] padding { get; set; }

		internal MaxUnpool3d(long[] kernel_size, long[] stride = null, long[] padding = null)
			: base("MaxUnpool3d")
		{
			this.kernel_size = kernel_size;
			this.stride = stride;
			this.padding = padding;
		}

		public override torch.Tensor forward(torch.Tensor tensor, torch.Tensor indices, long[] output_size = null)
		{
			return torch.nn.functional.max_unpool3d(tensor, indices, kernel_size, stride, padding, output_size);
		}

		public new torch.Tensor call(torch.Tensor tensor, torch.Tensor indices, long[] output_size = null)
		{
			return base.call(tensor, indices, output_size);
		}
	}
	public sealed class GRU : torch.nn.Module<torch.Tensor, torch.Tensor, (torch.Tensor, torch.Tensor)>
	{
		private long _hidden_size;

		private long _num_layers;

		private bool _bidirectional;

		private bool _batch_first;

		internal GRU(IntPtr handle, IntPtr boxedHandle, long hiddenSize, long numLayers, bool batchFirst, bool bidirectional)
			: base(handle, boxedHandle)
		{
			_hidden_size = hiddenSize;
			_num_layers = numLayers;
			_bidirectional = bidirectional;
			_batch_first = batchFirst;
		}

		public override (torch.Tensor, torch.Tensor) forward(torch.Tensor input, torch.Tensor h0 = null)
		{
			if ((object)h0 == null)
			{
				long dim = (_batch_first ? input.shape[0] : input.shape[1]);
				h0 = torch.zeros(((!_bidirectional) ? 1 : 2) * _num_layers, dim, _hidden_size, input.dtype, input.device);
			}
			IntPtr h_n;
			IntPtr intPtr = NativeMethods.THSNN_GRU_forward(handle, input.Handle, h0.Handle, out h_n);
			if (intPtr == IntPtr.Zero || h_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.Tensor(intPtr), new torch.Tensor(h_n));
		}

		public new (torch.Tensor, torch.Tensor) call(torch.Tensor input, torch.Tensor h0 = null)
		{
			return base.call(input, h0);
		}

		public (torch.nn.utils.rnn.PackedSequence, torch.Tensor) call(torch.nn.utils.rnn.PackedSequence input, torch.Tensor h0 = null)
		{
			if ((object)h0 == null)
			{
				torch.Tensor data = input.data;
				long dim = input.batch_sizes[0L].item<long>();
				h0 = torch.zeros(((!_bidirectional) ? 1 : 2) * _num_layers, dim, _hidden_size, data.dtype, data.device);
			}
			IntPtr h_n;
			torch.nn.utils.rnn.PackedSequence.HType hType = NativeMethods.THSNN_GRU_forward_with_packed_input(handle, input.Handle, h0.Handle, out h_n);
			if (hType.IsInvalid || h_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.nn.utils.rnn.PackedSequence(hType), new torch.Tensor(h_n));
		}

		public void flatten_parameters()
		{
			NativeMethods.THSNN_GRU_flatten_parameters(handle);
			torch.CheckForErrors();
		}
	}
	public sealed class GRUCell : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public Parameter? bias_ih
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_GRUCell_bias_ih(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("bias_ih cannot be set to 'null'");
				}
				NativeMethods.THSNN_GRUCell_set_bias_ih(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("bias_ih", value);
			}
		}

		public Parameter? bias_hh
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_GRUCell_bias_hh(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("bias_hh cannot be set to 'null'");
				}
				NativeMethods.THSNN_GRUCell_set_bias_hh(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("bias_hh", value);
			}
		}

		public Parameter? weight_ih
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_GRUCell_weight_ih(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight_ih cannot be set to 'null'");
				}
				NativeMethods.THSNN_GRUCell_set_weight_ih(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight_ih", value);
			}
		}

		public Parameter? weight_hh
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_GRUCell_weight_hh(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight_hh cannot be set to 'null'");
				}
				NativeMethods.THSNN_GRUCell_set_weight_hh(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight_hh", value);
			}
		}

		internal GRUCell(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor? h0 = null)
		{
			IntPtr intPtr = NativeMethods.THSNN_GRUCell_forward(handle, input.Handle, h0?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class LSTM : torch.nn.Module<torch.Tensor, (torch.Tensor, torch.Tensor)?, (torch.Tensor, torch.Tensor, torch.Tensor)>
	{
		private long _hidden_size;

		private long _num_layers;

		private bool _bidirectional;

		private bool _batch_first;

		internal LSTM(IntPtr handle, IntPtr boxedHandle, long hiddenSize, long numLayers, bool batchFirst, bool bidirectional)
			: base(handle, boxedHandle)
		{
			_hidden_size = hiddenSize;
			_num_layers = numLayers;
			_bidirectional = bidirectional;
			_batch_first = batchFirst;
		}

		public override (torch.Tensor, torch.Tensor, torch.Tensor) forward(torch.Tensor input, (torch.Tensor, torch.Tensor)? h0_c0 = null)
		{
			torch.Tensor tensor;
			torch.Tensor tensor2;
			if (!h0_c0.HasValue)
			{
				long dim = (_batch_first ? input.shape[0] : input.shape[1]);
				int num = ((!_bidirectional) ? 1 : 2);
				tensor = torch.zeros(num * _num_layers, dim, _hidden_size, input.dtype, input.device);
				tensor2 = torch.zeros(num * _num_layers, dim, _hidden_size, input.dtype, input.device);
			}
			else
			{
				tensor = h0_c0.Value.Item1;
				tensor2 = h0_c0.Value.Item2;
			}
			IntPtr h_n;
			IntPtr c_n;
			IntPtr intPtr = NativeMethods.THSNN_LSTM_forward(handle, input.Handle, tensor.Handle, tensor2.Handle, out h_n, out c_n);
			if (intPtr == IntPtr.Zero || h_n == IntPtr.Zero || c_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.Tensor(intPtr), new torch.Tensor(h_n), new torch.Tensor(c_n));
		}

		public new (torch.Tensor, torch.Tensor, torch.Tensor) call(torch.Tensor input, (torch.Tensor, torch.Tensor)? h0_c0 = null)
		{
			return base.call(input, h0_c0);
		}

		public (torch.nn.utils.rnn.PackedSequence, torch.Tensor, torch.Tensor) call(torch.nn.utils.rnn.PackedSequence input, (torch.Tensor, torch.Tensor)? h0_c0 = null)
		{
			torch.Tensor tensor;
			torch.Tensor tensor2;
			if (!h0_c0.HasValue)
			{
				torch.Tensor data = input.data;
				long dim = input.batch_sizes[0L].item<long>();
				int num = ((!_bidirectional) ? 1 : 2);
				tensor = torch.zeros(num * _num_layers, dim, _hidden_size, data.dtype, data.device);
				tensor2 = torch.zeros(num * _num_layers, dim, _hidden_size, data.dtype, data.device);
			}
			else
			{
				tensor = h0_c0.Value.Item1;
				tensor2 = h0_c0.Value.Item2;
			}
			IntPtr h_n;
			IntPtr c_n;
			torch.nn.utils.rnn.PackedSequence.HType hType = NativeMethods.THSNN_LSTM_forward_with_packed_input(handle, input.Handle, tensor.Handle, tensor2.Handle, out h_n, out c_n);
			if (hType.IsInvalid || h_n == IntPtr.Zero || c_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.nn.utils.rnn.PackedSequence(hType), new torch.Tensor(h_n), new torch.Tensor(c_n));
		}

		public void flatten_parameters()
		{
			NativeMethods.THSNN_LSTM_flatten_parameters(handle);
			torch.CheckForErrors();
		}
	}
	public sealed class LSTMCell : torch.nn.Module<torch.Tensor, (torch.Tensor, torch.Tensor)?, (torch.Tensor, torch.Tensor)>
	{
		public Parameter? bias_ih
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_LSTMCell_bias_ih(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("bias_ih cannot be set to 'null'");
				}
				NativeMethods.THSNN_LSTMCell_set_bias_ih(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("bias_ih", value);
			}
		}

		public Parameter? bias_hh
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_LSTMCell_bias_hh(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("bias_hh cannot be set to 'null'");
				}
				NativeMethods.THSNN_LSTMCell_set_bias_hh(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("bias_hh", value);
			}
		}

		public Parameter? weight_ih
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_LSTMCell_weight_ih(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight_ih cannot be set to 'null'");
				}
				NativeMethods.THSNN_LSTMCell_set_weight_ih(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight_ih", value);
			}
		}

		public Parameter? weight_hh
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_LSTMCell_weight_hh(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight_hh cannot be set to 'null'");
				}
				NativeMethods.THSNN_LSTMCell_set_weight_hh(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight_hh", value);
			}
		}

		internal LSTMCell(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override (torch.Tensor, torch.Tensor) forward(torch.Tensor input, (torch.Tensor, torch.Tensor)? h0_c0)
		{
			IntPtr c_n;
			IntPtr intPtr = NativeMethods.THSNN_LSTMCell_forward(handle, input.Handle, h0_c0?.Item1.Handle ?? IntPtr.Zero, h0_c0?.Item2.Handle ?? IntPtr.Zero, out c_n);
			if (intPtr == IntPtr.Zero || c_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.Tensor(intPtr), new torch.Tensor(c_n));
		}

		public new (torch.Tensor, torch.Tensor) call(torch.Tensor input, (torch.Tensor, torch.Tensor)? h0_c0 = null)
		{
			return base.call(input, h0_c0);
		}
	}
	public sealed class RNN : torch.nn.Module<torch.Tensor, torch.Tensor?, (torch.Tensor, torch.Tensor)>
	{
		private long _hidden_size;

		private long _num_layers;

		private bool _bidirectional;

		private bool _batch_first;

		internal RNN(IntPtr handle, IntPtr boxedHandle, long hiddenSize, long numLayers, bool batchFirst, bool bidirectional)
			: base(handle, boxedHandle)
		{
			_hidden_size = hiddenSize;
			_num_layers = numLayers;
			_bidirectional = bidirectional;
			_batch_first = batchFirst;
		}

		public override (torch.Tensor, torch.Tensor) forward(torch.Tensor input, torch.Tensor? h0)
		{
			if ((object)h0 == null)
			{
				long dim = (_batch_first ? input.shape[0] : input.shape[1]);
				h0 = torch.zeros(((!_bidirectional) ? 1 : 2) * _num_layers, dim, _hidden_size, input.dtype, input.device);
			}
			IntPtr h_n;
			IntPtr intPtr = NativeMethods.THSNN_RNN_forward(handle, input.Handle, h0.Handle, out h_n);
			if (intPtr == IntPtr.Zero || h_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.Tensor(intPtr), new torch.Tensor(h_n));
		}

		public new (torch.Tensor, torch.Tensor) call(torch.Tensor input, torch.Tensor? h0 = null)
		{
			return base.call(input, h0);
		}

		public (torch.nn.utils.rnn.PackedSequence, torch.Tensor) call(torch.nn.utils.rnn.PackedSequence input, torch.Tensor? h0 = null)
		{
			if ((object)h0 == null)
			{
				torch.Tensor data = input.data;
				long dim = input.batch_sizes[0L].item<long>();
				h0 = torch.zeros(((!_bidirectional) ? 1 : 2) * _num_layers, dim, _hidden_size, data.dtype, data.device);
			}
			IntPtr h_n;
			torch.nn.utils.rnn.PackedSequence.HType hType = NativeMethods.THSNN_RNN_forward_with_packed_input(handle, input.Handle, h0.Handle, out h_n);
			if (hType.IsInvalid || h_n == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return (new torch.nn.utils.rnn.PackedSequence(hType), new torch.Tensor(h_n));
		}

		public void flatten_parameters()
		{
			NativeMethods.THSNN_RNN_flatten_parameters(handle);
			torch.CheckForErrors();
		}

		public Parameter? get_bias_ih(long idx)
		{
			IntPtr intPtr = NativeMethods.THSNN_RNN_bias_ih(handle, idx);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			if (!(intPtr == IntPtr.Zero))
			{
				return new Parameter(intPtr);
			}
			return null;
		}

		public Parameter? get_bias_hh(long idx)
		{
			IntPtr intPtr = NativeMethods.THSNN_RNN_bias_hh(handle, idx);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			if (!(intPtr == IntPtr.Zero))
			{
				return new Parameter(intPtr);
			}
			return null;
		}

		public Parameter? get_weight_ih(long idx)
		{
			IntPtr intPtr = NativeMethods.THSNN_RNN_weight_ih(handle, idx);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			if (!(intPtr == IntPtr.Zero))
			{
				return new Parameter(intPtr);
			}
			return null;
		}

		public Parameter? get_weight_hh(long idx)
		{
			IntPtr intPtr = NativeMethods.THSNN_RNN_weight_hh(handle, idx);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			if (!(intPtr == IntPtr.Zero))
			{
				return new Parameter(intPtr);
			}
			return null;
		}
	}
	public sealed class RNNCell : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		public Parameter? bias_ih
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_RNNCell_bias_ih(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("bias_ih cannot be set to 'null'");
				}
				NativeMethods.THSNN_RNNCell_set_bias_ih(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("bias_ih", value);
			}
		}

		public Parameter? bias_hh
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_RNNCell_bias_hh(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("bias_hh cannot be set to 'null'");
				}
				NativeMethods.THSNN_RNNCell_set_bias_hh(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("bias_hh", value);
			}
		}

		public Parameter? weight_ih
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_RNNCell_weight_ih(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight_ih cannot be set to 'null'");
				}
				NativeMethods.THSNN_RNNCell_set_weight_ih(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight_ih", value);
			}
		}

		public Parameter? weight_hh
		{
			get
			{
				IntPtr intPtr = NativeMethods.THSNN_RNNCell_weight_hh(handle);
				if (intPtr == IntPtr.Zero)
				{
					torch.CheckForErrors();
				}
				if (!(intPtr == IntPtr.Zero))
				{
					return new Parameter(intPtr);
				}
				return null;
			}
			set
			{
				if ((object)value == null)
				{
					throw new ArgumentNullException("weight_hh cannot be set to 'null'");
				}
				NativeMethods.THSNN_RNNCell_set_weight_hh(handle, value?.Handle ?? IntPtr.Zero);
				torch.CheckForErrors();
				ConditionallyRegisterParameter("weight_hh", value);
			}
		}

		internal RNNCell(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor input, torch.Tensor? h0 = null)
		{
			IntPtr intPtr = NativeMethods.THSNN_RNNCell_forward(handle, input.Handle, h0?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public class Sequential : torch.nn.Module<torch.Tensor, torch.Tensor>
	{
		private List<torch.nn.IModule<torch.Tensor, torch.Tensor>> _modules = new List<torch.nn.IModule<torch.Tensor, torch.Tensor>>();

		private List<string> _names = new List<string>();

		public int Count => _modules.Count;

		[IndexerName("SequentialItems")]
		public torch.nn.IModule<torch.Tensor, torch.Tensor> this[int index] => _modules[index];

		[IndexerName("SequentialItems")]
		public Sequential this[(int? start, int? end) index]
		{
			get
			{
				int start = (index.start.HasValue ? index.start.Value : 0);
				int end = (index.end.HasValue ? index.end.Value : _modules.Count);
				return Slice(start, end);
			}
		}

		public Sequential append(string name, torch.nn.IModule<torch.Tensor, torch.Tensor> module)
		{
			Add(name, module);
			return this;
		}

		internal void Add(string name, torch.nn.IModule<torch.Tensor, torch.Tensor> sm)
		{
			_ = (torch.nn.Module)sm;
			_modules.Add(sm);
			_names.Add(name);
		}

		public Sequential append(torch.nn.IModule<torch.Tensor, torch.Tensor> module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
			return this;
		}

		internal void Add(torch.nn.IModule<torch.Tensor, torch.Tensor> module)
		{
			string text = _modules.Count.ToString();
			Add(text, module);
		}

		public override IEnumerable<(string name, Parameter parameter)> named_parameters(bool recurse = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, parameter) in ((torch.nn.Module)_modules[i]).named_parameters())
				{
					if (!seen.Contains(parameter.handle))
					{
						seen.Add(parameter.handle);
						yield return (name: _names[i] + "." + text, parameter: parameter);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.Tensor buffer)> named_buffers(bool recurse = true, bool include_persistent = true)
		{
			if (!recurse)
			{
				yield break;
			}
			HashSet<IntPtr> seen = new HashSet<IntPtr> { IntPtr.Zero };
			for (int i = 0; i < _names.Count; i++)
			{
				foreach (var (text, tensor) in ((torch.nn.Module)_modules[i]).named_buffers(recurse: true, include_persistent))
				{
					if (!seen.Contains(tensor.handle))
					{
						seen.Add(tensor.handle);
						yield return (name: _names[i] + "." + text, buffer: tensor);
					}
				}
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_children()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: (torch.nn.Module)_modules[i]);
			}
		}

		public override IEnumerable<(string name, torch.nn.Module module)> named_modules()
		{
			for (int i = 0; i < _names.Count; i++)
			{
				yield return (name: _names[i] ?? "", module: (torch.nn.Module)_modules[i]);
			}
			for (int i = 0; i < _names.Count; i++)
			{
				torch.nn.Module module = (torch.nn.Module)_modules[i];
				string name = _names[i];
				foreach (var (text, item) in module.named_modules())
				{
					yield return (name: name + "." + text, module: item);
				}
			}
		}

		internal Sequential(IntPtr handle)
			: base(handle, IntPtr.Zero)
		{
		}

		protected Sequential(params (string name, torch.nn.Module<torch.Tensor, torch.Tensor> submodule)[] modules)
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
			for (int i = 0; i < modules.Length; i++)
			{
				(string, torch.nn.Module<torch.Tensor, torch.Tensor>) tuple = modules[i];
				Add(tuple.Item1, tuple.Item2);
			}
		}

		protected Sequential(params torch.nn.Module<torch.Tensor, torch.Tensor>[] modules)
			: base(IntPtr.Zero, IntPtr.Zero)
		{
			IntPtr intPtr = NativeMethods.THSNN_Sequential_ctor();
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			handle = new HType(intPtr, ownsHandle: true);
			foreach (torch.nn.Module<torch.Tensor, torch.Tensor> module in modules)
			{
				Add(module);
			}
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			if (_modules.Count == 0)
			{
				return tensor.alias();
			}
			if (_modules.Count == 1)
			{
				return _modules[0].call(tensor);
			}
			torch.Tensor tensor2 = _modules[0].call(tensor);
			for (int i = 1; i < _modules.Count - 1; i++)
			{
				torch.Tensor tensor3 = _modules[i].call(tensor2);
				tensor2.Dispose();
				tensor2 = tensor3;
			}
			torch.Tensor result = _modules[_modules.Count - 1].call(tensor2);
			tensor2.Dispose();
			return result;
		}

		public override torch.nn.Module apply(Action<torch.nn.Module> fn)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module.apply(fn);
			}
			fn(this);
			return this;
		}

		private Sequential Slice(int start, int end)
		{
			if (start < 0 || start > _modules.Count)
			{
				throw new IndexOutOfRangeException($"{start} is not a valid index.");
			}
			if (end < 0 || end > _modules.Count)
			{
				throw new IndexOutOfRangeException($"{end} is not a valid index.");
			}
			int num = Math.Min(_modules.Count, end);
			Sequential sequential = new Sequential(Array.Empty<torch.nn.Module<torch.Tensor, torch.Tensor>>());
			for (int i = start; i < num; i++)
			{
				sequential.Add(_names[i], _modules[i]);
			}
			return sequential;
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				foreach (torch.nn.Module module in _modules)
				{
					module.Dispose();
				}
			}
			base.Dispose(disposing);
		}

		public override void train(bool on = true)
		{
			base.train(on);
			foreach (torch.nn.Module module in _modules)
			{
				module.train(on);
			}
		}

		public override void eval()
		{
			base.eval();
			foreach (torch.nn.Module module in _modules)
			{
				module.eval();
			}
		}

		protected internal override torch.nn.Module _to(torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(torch.Device device, torch.ScalarType dtype, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(device, dtype, non_blocking);
			}
			return this;
		}

		protected internal override torch.nn.Module _to(DeviceType deviceType, int deviceIndex, bool non_blocking)
		{
			foreach (torch.nn.Module module in _modules)
			{
				module._to(deviceType, deviceIndex, non_blocking);
			}
			return this;
		}
	}
	public sealed class ChannelShuffle : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long groups { get; set; }

		internal ChannelShuffle(long groups)
			: base("ChannelShuffle")
		{
			this.groups = groups;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return tensor.channel_shuffle(groups);
		}

		public override string GetName()
		{
			return typeof(ChannelShuffle).Name;
		}
	}
	public sealed class Transformer : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		internal Transformer(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public torch.Tensor call(torch.Tensor src, torch.Tensor tgt, torch.Tensor src_mask, torch.Tensor? tgt_mask = null, torch.Tensor? memory_mask = null, torch.Tensor? src_key_padding_mask = null, torch.Tensor? tgt_key_padding_mask = null, torch.Tensor? memory_key_padding_mask = null)
		{
			IntPtr intPtr = NativeMethods.THSNN_Transformer_forward(handle, src.Handle, tgt.Handle, src_mask?.Handle ?? IntPtr.Zero, tgt_mask?.Handle ?? IntPtr.Zero, memory_mask?.Handle ?? IntPtr.Zero, src_key_padding_mask?.Handle ?? IntPtr.Zero, tgt_key_padding_mask?.Handle ?? IntPtr.Zero, memory_key_padding_mask?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public override torch.Tensor forward(torch.Tensor src, torch.Tensor tgt)
		{
			IntPtr intPtr = NativeMethods.THSNN_Transformer_forward(handle, src.Handle, tgt.Handle, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class TransformerDecoder : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		internal TransformerDecoder(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor tgt, torch.Tensor memory, torch.Tensor tgt_mask, torch.Tensor memory_mask = null, torch.Tensor tgt_key_padding_mask = null, torch.Tensor memory_key_padding_mask = null)
		{
			IntPtr intPtr = NativeMethods.THSNN_TransformerDecoder_forward(handle, tgt.Handle, memory.Handle, tgt_mask?.Handle ?? IntPtr.Zero, memory_mask?.Handle ?? IntPtr.Zero, tgt_key_padding_mask?.Handle ?? IntPtr.Zero, memory_key_padding_mask?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public new torch.Tensor call(torch.Tensor tgt, torch.Tensor memory, torch.Tensor tgt_mask, torch.Tensor memory_mask = null, torch.Tensor tgt_key_padding_mask = null, torch.Tensor memory_key_padding_mask = null)
		{
			return base.call(tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask);
		}

		public torch.Tensor call(torch.Tensor tgt, torch.Tensor memory)
		{
			return base.call(tgt, memory, (torch.Tensor)null, (torch.Tensor)null, (torch.Tensor)null, (torch.Tensor)null);
		}
	}
	public sealed class TransformerDecoderLayer : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor, torch.Tensor>
	{
		internal TransformerDecoderLayer(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor tgt, torch.Tensor memory, torch.Tensor tgt_mask, torch.Tensor memory_mask, torch.Tensor tgt_key_padding_mask, torch.Tensor memory_key_padding_mask)
		{
			IntPtr intPtr = NativeMethods.THSNN_TransformerDecoderLayer_forward(handle, tgt.Handle, memory.Handle, tgt_mask?.Handle ?? IntPtr.Zero, memory_mask?.Handle ?? IntPtr.Zero, tgt_key_padding_mask?.Handle ?? IntPtr.Zero, memory_key_padding_mask?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public new torch.Tensor call(torch.Tensor tgt, torch.Tensor memory, torch.Tensor tgt_mask, torch.Tensor memory_mask = null, torch.Tensor tgt_key_padding_mask = null, torch.Tensor memory_key_padding_mask = null)
		{
			return base.call(tgt, memory, tgt_mask, memory_mask, tgt_key_padding_mask, memory_key_padding_mask);
		}

		public torch.Tensor call(torch.Tensor tgt, torch.Tensor memory)
		{
			return base.call(tgt, memory, (torch.Tensor)null, (torch.Tensor)null, (torch.Tensor)null, (torch.Tensor)null);
		}
	}
	public sealed class TransformerEncoder : torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor>
	{
		public enum Activations
		{
			ReLU,
			GELU
		}

		internal TransformerEncoder(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public override torch.Tensor forward(torch.Tensor src, torch.Tensor src_mask, torch.Tensor src_key_padding_mask)
		{
			IntPtr intPtr = NativeMethods.THSNN_TransformerEncoder_forward(handle, src.Handle, src_mask?.Handle ?? IntPtr.Zero, src_key_padding_mask?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public torch.Tensor call(torch.Tensor src, torch.Tensor src_mask)
		{
			return call(src, src_mask, null);
		}

		public torch.Tensor call(torch.Tensor src)
		{
			return call(src, null, null);
		}
	}
	public sealed class TransformerEncoderLayer : torch.nn.Module<torch.Tensor, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor, torch.Tensor>, torch.nn.IModule<torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor>
	{
		internal TransformerEncoderLayer(IntPtr handle, IntPtr boxedHandle)
			: base(handle, boxedHandle)
		{
		}

		public torch.Tensor call(torch.Tensor src, torch.Tensor src_mask, torch.Tensor src_key_padding_mask)
		{
			IntPtr intPtr = NativeMethods.THSNN_TransformerEncoderLayer_forward(handle, src.Handle, src_mask?.Handle ?? IntPtr.Zero, src_key_padding_mask?.Handle ?? IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public torch.Tensor call(torch.Tensor src, torch.Tensor src_mask)
		{
			IntPtr intPtr = NativeMethods.THSNN_TransformerEncoderLayer_forward(handle, src.Handle, src_mask?.Handle ?? IntPtr.Zero, IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}

		public override torch.Tensor forward(torch.Tensor src)
		{
			IntPtr intPtr = NativeMethods.THSNN_TransformerEncoderLayer_forward(handle, src.Handle, IntPtr.Zero, IntPtr.Zero);
			if (intPtr == IntPtr.Zero)
			{
				torch.CheckForErrors();
			}
			return new torch.Tensor(intPtr);
		}
	}
	public sealed class Unflatten : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public long dim { get; set; }

		public long[] unflattened_size { get; set; }

		internal Unflatten(long dim, long[] unflattened_size)
			: base("Unflatten")
		{
			this.dim = dim;
			this.unflattened_size = unflattened_size;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return tensor.unflatten(dim, unflattened_size);
		}
	}
	public sealed class Unfold : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		public (long, long) kernel_size { get; set; }

		public (long, long) dilation { get; set; }

		public (long, long) padding { get; set; }

		public (long, long) stride { get; set; }

		internal Unfold((long, long) kernel_size, (long, long) dilation, (long, long) padding, (long, long) stride)
			: base("Unfold")
		{
			this.kernel_size = kernel_size;
			this.dilation = dilation;
			this.padding = padding;
			this.stride = stride;
		}

		public override torch.Tensor forward(torch.Tensor tensor)
		{
			return torch.nn.functional.unfold(tensor, kernel_size, dilation, padding, stride);
		}
	}
	public sealed class Upsample : ParameterLessModule<torch.Tensor, torch.Tensor>
	{
		private long[]? _size;

		private double[]? _scale_factor;

		public bool? recompute_scale_factor { get; set; }

		public torch.UpsampleMode mode { get; private set; }

		public bool? align_corners { get; private set; }

		public ReadOnlySpan<long> size
		{
			get
			{
				if (_size != null)
				{
					return new ReadOnlySpan<long>(_size);
				}
				return null;
			}
		}

		public ReadOnlySpan<double> scale_factor
		{
			get
			{
				if (_scale_factor != null)
				{
					return new ReadOnlySpan<double>(_scale_factor);
				}
				return null;
			}
		}

		internal Upsample(long[]? size, double[]? scale_factor, torch.UpsampleMode mode, bool? align_corners, bool? recompute_scale_factor)
			: base("Upsample")
		{
			_size = size;
			_scale_factor = scale_factor;
			this.mode = mode;
			this.align_corners = align_corners;
			this.recompute_scale_factor = recompute_scale_factor;
		}

		public override torch.Tensor forward(torch.Tensor input)
		{
			return torch.nn.functional.interpolate(input, _size, _scale_factor, (torch.InterpolationMode)mode, align_corners, recompute_scale_factor == true);
		}
	}
	public class Adadelta : OptimizerHelper
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor square_avg;

			public torch.Tensor acc_delta;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					square_avg.Dispose();
					acc_delta.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				square_avg = square_avg.to(device);
				acc_delta = acc_delta.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(square_avg, reader);
				TensorExtensionMethods.Load(acc_delta, reader);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				square_avg.Save(writer);
				acc_delta.Save(writer);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				square_avg.Dispose();
				acc_delta.Dispose();
				step = state.step;
				square_avg = state.square_avg.to(_parameter.device, copy: true);
				acc_delta = state.acc_delta.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && square_avg.allclose(state.square_avg))
				{
					return acc_delta.allclose(state.acc_delta);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				square_avg?.Dispose();
				acc_delta?.Dispose();
				step = 0L;
				square_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				acc_delta = torch.zeros_like(_parameter).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public double? rho;

			public double? eps;

			public double? weight_decay;

			public bool? maximize;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				rho = options.rho;
				eps = options.eps;
				weight_decay = options.weight_decay;
				maximize = options.maximize;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				rho = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				maximize = reader.ReadBoolean();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(rho.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
				writer.Write(maximize.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>
		{
			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 1.0, double rho = 0.9, double eps = 1E-06, double weight_decay = 0.0, bool maximize = false)
				: base(parameters, new Options
				{
					LearningRate = lr,
					rho = rho,
					eps = eps,
					weight_decay = weight_decay,
					maximize = maximize
				})
			{
			}
		}

		public Adadelta(IEnumerable<Parameter> parameters, double lr, double rho = 0.9, double eps = 1E-06, double weight_decay = 0.0, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, rho, eps, weight_decay, maximize)
		{
		}

		public Adadelta(IEnumerable<ParamGroup> parameters, double lr = 1.0, double rho = 0.9, double eps = 1E-06, double weight_decay = 0.0, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (rho < 0.0 || rho > 1.0)
			{
				throw new ArgumentException($"Invalid rho value: {rho}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid eps value: {eps}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				rho = rho,
				eps = eps,
				maximize = maximize,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.rho.Value;
				double value2 = options.eps.Value;
				double value3 = options.weight_decay.Value;
				bool value4 = options.maximize.Value;
				double value5 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (value4)
						{
							tensor = -tensor;
						}
						if (tensor.is_sparse)
						{
							throw new ArgumentException("Adadelta does not support sparse gradients");
						}
						State obj = (State)_state[parameter.handle];
						torch.Tensor square_avg = obj.square_avg;
						torch.Tensor acc_delta = obj.acc_delta;
						tensor = ((value3 != 0.0) ? tensor.add(parameter, value3) : tensor.alias());
						square_avg.mul_(value).addcmul_(tensor, tensor, 1.0 - value);
						torch.Tensor target = square_avg.add(value2).sqrt_();
						torch.Tensor tensor2 = acc_delta.add(value2).sqrt_().div_(target)
							.mul_(tensor);
						parameter.add_(tensor2, 0.0 - value5);
						acc_delta.mul_(value).addcmul_(tensor2, tensor2, 1.0 - value);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.rho.HasValue)
			{
				options2.rho = options.rho;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(param_group.Options);
			}
		}
	}
	public class Adagrad : OptimizerHelper
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor sum;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					sum.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				sum = sum.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(sum, reader);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				sum.Dispose();
				step = state.step;
				sum = state.sum.to(_parameter.device, copy: true);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				sum.Save(writer);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step)
				{
					return sum.allclose(state.sum);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				sum?.Dispose();
				step = 0L;
				Scalar value = (torch.is_complex(_parameter.dtype) ? ((Scalar)new Complex((options as Options).initial_accumulator_value.Value, (options as Options).initial_accumulator_value.Value)) : ((Scalar)(options as Options).initial_accumulator_value.Value));
				sum = torch.full_like(_parameter, value).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public double? lr_decay;

			public double? initial_accumulator_value;

			public double? eps;

			public double? weight_decay;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				lr_decay = options.lr_decay;
				initial_accumulator_value = options.initial_accumulator_value;
				eps = options.eps;
				weight_decay = options.weight_decay;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				lr_decay = reader.ReadDouble();
				initial_accumulator_value = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(lr_decay.Value);
				writer.Write(initial_accumulator_value.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>
		{
			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.01, double lr_decay = 0.0, double weight_decay = 0.0, double initial_accumulator_value = 0.0, double eps = 1E-10)
				: base(parameters, new Options
				{
					LearningRate = lr,
					lr_decay = lr_decay,
					initial_accumulator_value = initial_accumulator_value,
					weight_decay = weight_decay,
					eps = eps
				})
			{
			}
		}

		public Adagrad(IEnumerable<Parameter> parameters, double lr = 0.01, double lr_decay = 0.0, double weight_decay = 0.0, double initial_accumulator_value = 0.0, double eps = 1E-10)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, lr_decay, weight_decay, initial_accumulator_value, eps)
		{
		}

		public Adagrad(IEnumerable<ParamGroup> parameters, double lr = 0.01, double lr_decay = 0.0, double weight_decay = 0.0, double initial_accumulator_value = 0.0, double eps = 1E-10)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid ε: {eps}");
			}
			if (lr_decay < 0.0)
			{
				throw new ArgumentException($"Invalid lr_decay value: {lr_decay}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			if (initial_accumulator_value < 0.0)
			{
				throw new ArgumentException($"Invalid initial_accumulator_value: {initial_accumulator_value}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				lr_decay = lr_decay,
				eps = eps,
				initial_accumulator_value = initial_accumulator_value,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.lr_decay.Value;
				double value2 = options.weight_decay.Value;
				double value3 = options.eps.Value;
				_ = options.initial_accumulator_value.Value;
				double value4 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					State state = (State)_state[parameter.handle];
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						state.step++;
						if (value2 != 0.0)
						{
							tensor = tensor.add(parameter, value2);
						}
						double num = value4 / (1.0 + (double)(state.step - 1) * value);
						if (tensor.is_sparse)
						{
							throw new NotImplementedException("Adagrad optimization over sparse parameters");
						}
						if (torch.is_complex(tensor))
						{
							throw new NotImplementedException("Adagrad optimization over complex parameters");
						}
						state.sum.addcmul_(tensor, tensor, 1);
						torch.Tensor tensor2 = state.sum.sqrt().add_(value3);
						parameter.addcdiv_(tensor, tensor2, 0.0 - num);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.lr_decay.HasValue)
			{
				options2.lr_decay = options.lr_decay;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.initial_accumulator_value.HasValue)
			{
				options2.initial_accumulator_value = options.initial_accumulator_value;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(param_group.Options);
			}
		}
	}
	public class Adam : OptimizerHelper, torch.optim.IBetas
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor exp_avg;

			public torch.Tensor exp_avg_sq;

			public torch.Tensor max_exp_avg_sq;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					exp_avg.Dispose();
					exp_avg_sq.Dispose();
					max_exp_avg_sq?.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				exp_avg = exp_avg.to(device);
				exp_avg_sq = exp_avg_sq.to(device);
				max_exp_avg_sq = max_exp_avg_sq?.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(exp_avg, reader);
				TensorExtensionMethods.Load(exp_avg_sq, reader);
				OptimizerState.LoadConditionalStateTensor(reader, ref max_exp_avg_sq, _parameter.device);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				exp_avg.Save(writer);
				exp_avg_sq.Save(writer);
				if ((object)max_exp_avg_sq != null)
				{
					writer.Write(value: true);
					max_exp_avg_sq.Save(writer);
				}
				else
				{
					writer.Write(value: false);
				}
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				exp_avg.Dispose();
				exp_avg_sq.Dispose();
				max_exp_avg_sq?.Dispose();
				step = state.step;
				exp_avg = state.exp_avg.to(_parameter.device, copy: true);
				exp_avg_sq = state.exp_avg_sq.to(_parameter.device, copy: true);
				max_exp_avg_sq = state.max_exp_avg_sq?.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && exp_avg.allclose(state.exp_avg) && exp_avg_sq.allclose(state.exp_avg_sq))
				{
					if ((object)max_exp_avg_sq != null)
					{
						return max_exp_avg_sq.allclose(state.max_exp_avg_sq);
					}
					return true;
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				exp_avg?.Dispose();
				exp_avg_sq?.Dispose();
				max_exp_avg_sq?.Dispose();
				step = 0L;
				exp_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				exp_avg_sq = torch.zeros_like(_parameter).DetachFromDisposeScope();
				max_exp_avg_sq = null;
				if ((options as Options).amsgrad.Value)
				{
					max_exp_avg_sq = torch.zeros_like(_parameter).DetachFromDisposeScope();
				}
			}
		}

		public class Options : OptimizerOptions
		{
			public double? beta1;

			public double? beta2;

			public double? weight_decay;

			public double? eps;

			public bool? amsgrad;

			public bool? maximize;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				beta1 = options.beta1;
				beta2 = options.beta2;
				eps = options.eps;
				weight_decay = options.weight_decay;
				amsgrad = options.amsgrad;
				maximize = options.maximize;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				beta1 = reader.ReadDouble();
				beta2 = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				amsgrad = reader.ReadBoolean();
				maximize = reader.ReadBoolean();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(beta1.Value);
				writer.Write(beta2.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
				writer.Write(amsgrad.Value);
				writer.Write(maximize.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IBetas
		{
			public (double, double) Betas
			{
				get
				{
					return (base.Options.beta1.Value, base.Options.beta2.Value);
				}
				set
				{
					base.Options.beta1 = value.Item1;
					base.Options.beta2 = value.Item2;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
				: base(parameters, new Options
				{
					LearningRate = lr,
					beta1 = beta1,
					beta2 = beta2,
					eps = eps,
					weight_decay = weight_decay,
					amsgrad = amsgrad,
					maximize = maximize
				})
			{
			}
		}

		public (double, double) Betas
		{
			get
			{
				return ((_defaults as Options).beta1.Value, (_defaults as Options).beta2.Value);
			}
			set
			{
				(_defaults as Options).beta1 = value.Item1;
				(_defaults as Options).beta2 = value.Item2;
			}
		}

		public Adam(IEnumerable<Parameter> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, beta1, beta2, eps, weight_decay, amsgrad, maximize)
		{
		}

		public Adam(IEnumerable<ParamGroup> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid ε: {eps}");
			}
			if (beta1 < 0.0 || beta1 >= 1.0)
			{
				throw new ArgumentException($"Invalid beta1: {beta1}");
			}
			if (beta2 < 0.0 || beta2 >= 1.0)
			{
				throw new ArgumentException($"Invalid beta2: {beta2}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				beta1 = beta1,
				beta2 = beta2,
				maximize = maximize,
				eps = eps,
				amsgrad = amsgrad,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.beta1.Value;
				double value2 = options.beta2.Value;
				double value3 = options.weight_decay.Value;
				bool value4 = options.amsgrad.Value;
				bool value5 = options.maximize.Value;
				double value6 = options.eps.Value;
				double value7 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					State state = (State)_state[parameter.handle];
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (value5)
						{
							tensor = -tensor;
						}
						state.step++;
						double num = 1.0 - Math.Pow(value, state.step);
						double d = 1.0 - Math.Pow(value2, state.step);
						if (value3 != 0.0)
						{
							tensor = tensor.add(parameter, value3);
						}
						state.exp_avg.mul_(value).add_(tensor, 1.0 - value);
						state.exp_avg_sq.mul_(value2).addcmul_(tensor, tensor.conj(), 1.0 - value2);
						torch.Tensor tensor2 = null;
						if (value4)
						{
							torch.Tensor max_exp_avg_sq = state.max_exp_avg_sq;
							state.max_exp_avg_sq = torch.maximum(max_exp_avg_sq, state.exp_avg_sq).DetachFromDisposeScope();
							max_exp_avg_sq.Dispose();
							tensor2 = (state.max_exp_avg_sq.sqrt() / Math.Sqrt(d)).add_(value6);
						}
						else
						{
							tensor2 = (state.exp_avg_sq.sqrt() / Math.Sqrt(d)).add_(value6);
						}
						double num2 = value7 / num;
						parameter.addcdiv_(state.exp_avg, tensor2, 0.0 - num2);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.beta1.HasValue)
			{
				options2.beta1 = options.beta1;
			}
			if (!options2.beta2.HasValue)
			{
				options2.beta2 = options.beta2;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.amsgrad.HasValue)
			{
				options2.amsgrad = options.amsgrad;
			}
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class Adamax : OptimizerHelper, torch.optim.IBetas
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor exp_avg;

			public torch.Tensor exp_inf;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					exp_avg.Dispose();
					exp_inf.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				exp_avg = exp_avg.to(device);
				exp_inf = exp_inf.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(exp_avg, reader);
				TensorExtensionMethods.Load(exp_inf, reader);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				exp_avg.Save(writer);
				exp_inf.Save(writer);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				exp_avg.Dispose();
				exp_inf.Dispose();
				step = state.step;
				exp_avg = state.exp_avg.to(_parameter.device, copy: true);
				exp_inf = state.exp_inf.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && exp_avg.allclose(state.exp_avg))
				{
					return exp_inf.allclose(state.exp_inf);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				exp_avg?.Dispose();
				exp_inf?.Dispose();
				step = 0L;
				exp_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				exp_inf = torch.zeros_like(_parameter).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public double? beta1;

			public double? beta2;

			public double? eps;

			public double? weight_decay;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				beta1 = options.beta1;
				beta2 = options.beta2;
				eps = options.eps;
				weight_decay = options.weight_decay;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				beta1 = reader.ReadDouble();
				beta2 = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(beta1.Value);
				writer.Write(beta2.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IBetas
		{
			public (double, double) Betas
			{
				get
				{
					return (base.Options.beta1.Value, base.Options.beta2.Value);
				}
				set
				{
					base.Options.beta1 = value.Item1;
					base.Options.beta2 = value.Item2;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 1.0, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
				: base(parameters, new Options
				{
					LearningRate = lr,
					beta1 = beta1,
					beta2 = beta2,
					eps = eps,
					weight_decay = weight_decay
				})
			{
			}
		}

		public (double, double) Betas
		{
			get
			{
				return ((_defaults as Options).beta1.Value, (_defaults as Options).beta2.Value);
			}
			set
			{
				(_defaults as Options).beta1 = value.Item1;
				(_defaults as Options).beta2 = value.Item2;
			}
		}

		public Adamax(IEnumerable<Parameter> parameters, double lr, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, beta1, beta2, eps, weight_decay)
		{
		}

		public Adamax(IEnumerable<ParamGroup> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (beta1 < 0.0 || beta1 > 1.0)
			{
				throw new ArgumentException($"Invalid beta1 value: {beta1}");
			}
			if (beta2 < 0.0 || beta2 > 1.0)
			{
				throw new ArgumentException($"Invalid beta2 value: {beta2}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid eps value: {eps}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				beta1 = beta1,
				beta2 = beta2,
				eps = eps,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.beta1.Value;
				double value2 = options.beta2.Value;
				double value3 = options.eps.Value;
				double value4 = options.weight_decay.Value;
				double value5 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					torch.Tensor grad = parameter.grad;
					if ((object)grad != null)
					{
						if (grad.is_sparse)
						{
							throw new ArgumentException("Adamax does not support sparse gradients");
						}
						State state = (State)_state[parameter.handle];
						state.step++;
						torch.Tensor exp_avg = state.exp_avg;
						torch.Tensor exp_inf = state.exp_inf;
						grad = ((value4 != 0.0) ? grad.add(parameter, value4) : grad.alias());
						exp_avg.mul_(value).add_(grad, 1.0 - value);
						torch.amax(torch.cat(new torch.Tensor[2]
						{
							exp_inf.mul_(value2).unsqueeze(0L),
							grad.abs().add_(value3).unsqueeze_(0L)
						}, 0L), new long[1], keepdim: false, exp_inf);
						double num = value5 / (1.0 - Math.Pow(value, state.step));
						parameter.addcdiv_(exp_avg, exp_inf, 0.0 - num);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.beta1.HasValue)
			{
				options2.beta1 = options.beta1;
			}
			if (!options2.beta2.HasValue)
			{
				options2.beta2 = options.beta2;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(param_group.Options);
			}
		}
	}
	public class AdamW : OptimizerHelper, torch.optim.IBetas
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor exp_avg;

			public torch.Tensor exp_avg_sq;

			public torch.Tensor max_exp_avg_sq;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					exp_avg.Dispose();
					exp_avg_sq.Dispose();
					max_exp_avg_sq?.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				exp_avg = exp_avg.to(device);
				exp_avg_sq = exp_avg_sq.to(device);
				max_exp_avg_sq = max_exp_avg_sq?.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(exp_avg, reader);
				TensorExtensionMethods.Load(exp_avg_sq, reader);
				if (reader.ReadBoolean())
				{
					if ((object)max_exp_avg_sq == null)
					{
						max_exp_avg_sq = torch.zeros_like(exp_avg_sq);
					}
					TensorExtensionMethods.Load(max_exp_avg_sq, reader);
				}
				else
				{
					max_exp_avg_sq?.Dispose();
					max_exp_avg_sq = null;
				}
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				exp_avg.Save(writer);
				exp_avg_sq.Save(writer);
				if ((object)max_exp_avg_sq != null)
				{
					writer.Write(value: true);
					max_exp_avg_sq.Save(writer);
				}
				else
				{
					writer.Write(value: false);
				}
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				exp_avg.Dispose();
				exp_avg_sq.Dispose();
				max_exp_avg_sq?.Dispose();
				step = state.step;
				exp_avg = state.exp_avg.to(_parameter.device, copy: true);
				exp_avg_sq = state.exp_avg_sq.to(_parameter.device, copy: true);
				max_exp_avg_sq = state.max_exp_avg_sq?.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && exp_avg.allclose(state.exp_avg) && exp_avg_sq.allclose(state.exp_avg_sq))
				{
					if ((object)max_exp_avg_sq != null)
					{
						return max_exp_avg_sq.allclose(state.max_exp_avg_sq);
					}
					return true;
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				exp_avg?.Dispose();
				exp_avg_sq?.Dispose();
				max_exp_avg_sq?.Dispose();
				step = 0L;
				exp_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				exp_avg_sq = torch.zeros_like(_parameter).DetachFromDisposeScope();
				max_exp_avg_sq = null;
				if ((options as Options).amsgrad.Value)
				{
					max_exp_avg_sq = torch.zeros_like(_parameter).DetachFromDisposeScope();
				}
			}
		}

		public class Options : OptimizerOptions
		{
			public double? beta1;

			public double? beta2;

			public double? weight_decay;

			public double? eps;

			public bool? amsgrad;

			public bool? maximize;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				beta1 = options.beta1;
				beta2 = options.beta2;
				eps = options.eps;
				weight_decay = options.weight_decay;
				amsgrad = options.amsgrad;
				maximize = options.maximize;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				beta1 = reader.ReadDouble();
				beta2 = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				amsgrad = reader.ReadBoolean();
				maximize = reader.ReadBoolean();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(beta1.Value);
				writer.Write(beta2.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
				writer.Write(amsgrad.Value);
				writer.Write(maximize.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IBetas
		{
			public (double, double) Betas
			{
				get
				{
					return (base.Options.beta1.Value, base.Options.beta2.Value);
				}
				set
				{
					base.Options.beta1 = value.Item1;
					base.Options.beta2 = value.Item2;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
				: base(parameters, new Options
				{
					LearningRate = lr,
					beta1 = beta1,
					beta2 = beta2,
					eps = eps,
					weight_decay = weight_decay,
					amsgrad = amsgrad,
					maximize = maximize
				})
			{
			}
		}

		public (double, double) Betas
		{
			get
			{
				return ((_defaults as Options).beta1.Value, (_defaults as Options).beta2.Value);
			}
			set
			{
				(_defaults as Options).beta1 = value.Item1;
				(_defaults as Options).beta2 = value.Item2;
			}
		}

		public AdamW(IEnumerable<Parameter> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, beta1, beta2, eps, weight_decay, amsgrad, maximize)
		{
		}

		public AdamW(IEnumerable<ParamGroup> parameters, double lr = 0.001, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, bool amsgrad = false, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid ε: {eps}");
			}
			if (beta1 < 0.0 || beta1 >= 1.0)
			{
				throw new ArgumentException($"Invalid beta1: {beta1}");
			}
			if (beta2 < 0.0 || beta2 >= 1.0)
			{
				throw new ArgumentException($"Invalid beta2: {beta2}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				beta1 = beta1,
				beta2 = beta2,
				maximize = maximize,
				eps = eps,
				amsgrad = amsgrad,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.beta1.Value;
				double value2 = options.beta2.Value;
				double value3 = options.weight_decay.Value;
				bool value4 = options.amsgrad.Value;
				bool value5 = options.maximize.Value;
				double value6 = options.eps.Value;
				double value7 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					State state = (State)_state[parameter.handle];
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (value5)
						{
							tensor = -tensor;
						}
						state.step++;
						parameter.mul_(1.0 - value7 * value3);
						double num = 1.0 - Math.Pow(value, state.step);
						double d = 1.0 - Math.Pow(value2, state.step);
						state.exp_avg.mul_(value).add_(tensor, 1.0 - value);
						state.exp_avg_sq.mul_(value2).addcmul_(tensor, tensor, 1.0 - value2);
						torch.Tensor tensor2 = null;
						if (value4)
						{
							torch.Tensor max_exp_avg_sq = state.max_exp_avg_sq;
							state.max_exp_avg_sq = torch.maximum(max_exp_avg_sq, state.exp_avg_sq).DetachFromDisposeScope();
							max_exp_avg_sq.Dispose();
							tensor2 = (state.max_exp_avg_sq.sqrt() / Math.Sqrt(d)).add_(value6);
						}
						else
						{
							tensor2 = (state.exp_avg_sq.sqrt() / Math.Sqrt(d)).add_(value6);
						}
						double num2 = value7 / num;
						parameter.addcdiv_(state.exp_avg, tensor2, 0.0 - num2);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.beta1.HasValue)
			{
				options2.beta1 = options.beta1;
			}
			if (!options2.beta2.HasValue)
			{
				options2.beta2 = options.beta2;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.amsgrad.HasValue)
			{
				options2.amsgrad = options.amsgrad;
			}
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class ASGD : OptimizerHelper
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public double eta;

			public double mu;

			public torch.Tensor ax;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					ax.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				ax = ax.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				eta = reader.ReadDouble();
				mu = reader.ReadDouble();
				TensorExtensionMethods.Load(ax, reader);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				step = state.step;
				eta = state.eta;
				mu = state.mu;
				ax.Dispose();
				ax = state.ax.to(_parameter.device, copy: true);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				writer.Write(eta);
				writer.Write(mu);
				ax.Save(writer);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && eta == state.eta && mu == state.mu)
				{
					return ax.allclose(state.ax);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				ax?.Dispose();
				step = 0L;
				eta = options.LearningRate.Value;
				mu = 1.0;
				ax = torch.zeros_like(_parameter).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public bool? maximize;

			public double? lambd;

			public double? alpha;

			public double? weight_decay;

			public double? t0;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				maximize = options.maximize;
				lambd = options.lambd;
				alpha = options.alpha;
				weight_decay = options.weight_decay;
				t0 = options.t0;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				maximize = reader.ReadBoolean();
				lambd = reader.ReadDouble();
				alpha = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				t0 = reader.ReadDouble();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(maximize.Value);
				writer.Write(lambd.Value);
				writer.Write(alpha.Value);
				writer.Write(weight_decay.Value);
				writer.Write(t0.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>
		{
			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.01, double lambd = 0.0001, double alpha = 0.75, double t0 = 1000000.0, double weight_decay = 0.0)
				: base(parameters, new Options
				{
					LearningRate = lr,
					lambd = lambd,
					alpha = alpha,
					t0 = t0,
					weight_decay = weight_decay
				})
			{
			}
		}

		public ASGD(IEnumerable<Parameter> parameters, double lr = 0.01, double lambd = 0.0001, double alpha = 0.75, double t0 = 1000000.0, double weight_decay = 0.0, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, lambd, alpha, t0, weight_decay, maximize)
		{
		}

		public ASGD(IEnumerable<ParamGroup<Options>> parameters, double lr = 0.01, double lambd = 0.0001, double alpha = 0.75, double t0 = 1000000.0, double weight_decay = 0.0, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				maximize = maximize,
				lambd = lambd,
				alpha = alpha,
				t0 = t0,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup<Options> parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				bool value = options.maximize.Value;
				double value2 = options.lambd.Value;
				double value3 = options.alpha.Value;
				double value4 = options.weight_decay.Value;
				double value5 = options.t0.Value;
				double value6 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (tensor.is_sparse)
						{
							throw new ArgumentException("ASGD does not support sparse gradients");
						}
						if (value)
						{
							tensor = -tensor;
						}
						State state = (State)_state[parameter.handle];
						state.step++;
						tensor = ((value4 != 0.0) ? tensor.add(parameter, value4) : tensor.alias());
						parameter.mul_(1.0 - value2 * state.eta);
						parameter.add_(tensor, 0.0 - state.eta);
						if (state.mu != 1.0)
						{
							state.ax.add_(parameter.sub(state.ax).mul(state.mu));
						}
						else
						{
							state.ax.copy_(parameter);
						}
						state.eta = value6 / Math.Pow(1.0 + value2 * value6 * (double)state.step, value3);
						state.mu = 1.0 / Math.Max(1.0, (double)state.step - value5);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
			_state.Clear();
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.lambd.HasValue)
			{
				options2.lambd = options.lambd;
			}
			if (!options2.alpha.HasValue)
			{
				options2.alpha = options.alpha;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.t0.HasValue)
			{
				options2.t0 = options.t0;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class LBFGS : torch.optim.Optimizer, torch.optim.ILearningRateController
	{
		public double _rate;

		private ParamGroup[] _paramGroups;

		public double LearningRate
		{
			get
			{
				return _rate;
			}
			set
			{
				NativeMethods.THSNN_LBFGS_set_lr(handle, value);
				torch.CheckForErrors();
				_rate = value;
			}
		}

		public double InitialLearningRate { get; set; }

		public override IEnumerable<torch.optim.ILearningRateController> ParamGroups => _paramGroups;

		public LBFGS(IntPtr handle, double lr)
			: base(handle)
		{
			_rate = lr;
			InitialLearningRate = lr;
			_paramGroups = new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters(),
					Options = new OptimizerOptions
					{
						LearningRate = lr,
						InitialLearningRate = lr
					}
				}
			};
		}

		public override torch.Tensor step(Func<torch.Tensor> closure)
		{
			if (closure == null)
			{
				throw new ArgumentNullException("'closure' must be non-null when using the LBFGS optimizer. See: https://pytorch.org/docs/1.9.0/optim.html");
			}
			return base.step(closure);
		}
	}
	public class NAdam : OptimizerHelper, torch.optim.IBetas
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public double mu_product;

			public torch.Tensor exp_avg;

			public torch.Tensor exp_avg_sq;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					exp_avg.Dispose();
					exp_avg_sq.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				exp_avg = exp_avg.to(device);
				exp_avg_sq = exp_avg_sq.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				mu_product = reader.ReadDouble();
				TensorExtensionMethods.Load(exp_avg, reader);
				TensorExtensionMethods.Load(exp_avg_sq, reader);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				writer.Write(mu_product);
				exp_avg.Save(writer);
				exp_avg_sq.Save(writer);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				exp_avg.Dispose();
				exp_avg_sq.Dispose();
				step = state.step;
				mu_product = state.mu_product;
				exp_avg = state.exp_avg.to(_parameter.device, copy: true);
				exp_avg_sq = state.exp_avg_sq.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && mu_product == state.mu_product && exp_avg.allclose(state.exp_avg))
				{
					return exp_avg_sq.allclose(state.exp_avg_sq);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				exp_avg?.Dispose();
				exp_avg_sq?.Dispose();
				step = 0L;
				mu_product = 1.0;
				exp_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				exp_avg_sq = torch.zeros_like(_parameter).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public double? beta1;

			public double? beta2;

			public double? eps;

			public double? weight_decay;

			public double? momentum_decay;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				beta1 = options.beta1;
				beta2 = options.beta2;
				eps = options.eps;
				weight_decay = options.weight_decay;
				momentum_decay = options.momentum_decay;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				beta1 = reader.ReadDouble();
				beta2 = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				momentum_decay = reader.ReadDouble();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(beta1.Value);
				writer.Write(beta2.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
				writer.Write(momentum_decay.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IBetas
		{
			public (double, double) Betas
			{
				get
				{
					return (base.Options.beta1.Value, base.Options.beta2.Value);
				}
				set
				{
					base.Options.beta1 = value.Item1;
					base.Options.beta2 = value.Item2;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 1.0, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, double momentum_decay = 0.004)
				: base(parameters, new Options
				{
					LearningRate = lr,
					beta1 = beta1,
					beta2 = beta2,
					eps = eps,
					weight_decay = weight_decay,
					momentum_decay = momentum_decay
				})
			{
			}
		}

		public (double, double) Betas
		{
			get
			{
				return ((_defaults as Options).beta1.Value, (_defaults as Options).beta2.Value);
			}
			set
			{
				(_defaults as Options).beta1 = value.Item1;
				(_defaults as Options).beta2 = value.Item2;
			}
		}

		public NAdam(IEnumerable<Parameter> parameters, double lr, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, double momentum_decay = 0.004)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, beta1, beta2, eps, weight_decay, momentum_decay)
		{
		}

		public NAdam(IEnumerable<ParamGroup> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0, double momentum_decay = 0.004)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (beta1 < 0.0 || beta1 > 1.0)
			{
				throw new ArgumentException($"Invalid beta1 value: {beta1}");
			}
			if (beta2 < 0.0 || beta2 > 1.0)
			{
				throw new ArgumentException($"Invalid beta2 value: {beta2}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid eps value: {eps}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			if (momentum_decay < 0.0)
			{
				throw new ArgumentException($"Invalid momentum_decay value: {momentum_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				beta1 = beta1,
				beta2 = beta2,
				eps = eps,
				weight_decay = weight_decay,
				momentum_decay = momentum_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.beta1.Value;
				double value2 = options.beta2.Value;
				double value3 = options.eps.Value;
				double value4 = options.weight_decay.Value;
				double value5 = options.momentum_decay.Value;
				double value6 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					torch.Tensor grad = parameter.grad;
					if ((object)grad != null)
					{
						State state = (State)_state[parameter.handle];
						state.step++;
						torch.Tensor exp_avg = state.exp_avg;
						torch.Tensor exp_avg_sq = state.exp_avg_sq;
						double num = 1.0 - Math.Pow(value2, state.step);
						grad = ((value4 != 0.0) ? grad.add(parameter, value4) : grad.alias());
						double num2 = value * (1.0 - 0.5 * Math.Pow(0.96, (double)state.step * value5));
						double num3 = value * (1.0 - 0.5 * Math.Pow(0.96, (double)(state.step + 1) * value5));
						double num4 = state.mu_product * num2;
						double num5 = num4 * num3;
						exp_avg.mul_(value).add_(grad, 1.0 - value);
						exp_avg_sq.mul_(value2).addcmul_(grad, grad, 1.0 - value2);
						torch.Tensor tensor = exp_avg_sq.div(num).sqrt_().add_(value3);
						parameter.addcdiv_(grad, tensor, (0.0 - value6) * (1.0 - num2) / (1.0 - num4));
						parameter.addcdiv_(exp_avg, tensor, (0.0 - value6) * num3 / (1.0 - num5));
						state.mu_product = num4;
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.beta1.HasValue)
			{
				options2.beta1 = options.beta1;
			}
			if (!options2.beta2.HasValue)
			{
				options2.beta2 = options.beta2;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.momentum_decay.HasValue)
			{
				options2.momentum_decay = options.momentum_decay;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public abstract class OptimizerHelper : torch.optim.Optimizer
	{
		protected enum TypeCode
		{
			Double,
			Long,
			Tensor,
			Options,
			State
		}

		protected OptimizerOptions _defaults;

		protected OrderedDict<IntPtr, OptimizerState> _state = new OrderedDict<IntPtr, OptimizerState>();

		public OptimizerHelper()
			: base(IntPtr.Zero)
		{
		}

		public void save_state_dict(string location)
		{
			using FileStream fileStream = File.Create(location);
			using BinaryWriter binaryWriter = new BinaryWriter(fileStream);
			save_state_dict(binaryWriter);
			binaryWriter.Flush();
			fileStream.Flush();
		}

		public void load_state_dict(string location)
		{
			using FileStream input = File.OpenRead(location);
			using BinaryReader reader = new BinaryReader(input);
			load_state_dict(reader);
		}

		public void save_state_dict(BinaryWriter writer)
		{
			writer.Write(GetType().Name);
			StateDictionary stateDictionary = state_dict();
			writer.Encode(stateDictionary.Options.Count);
			writer.Encode(stateDictionary.State.Count);
			foreach (OptimizerOptions option in stateDictionary.Options)
			{
				option.SaveStateDict(writer);
			}
			foreach (OptimizerState item in stateDictionary.State)
			{
				item.SaveStateDict(writer);
			}
		}

		public void load_state_dict(BinaryReader reader)
		{
			string text = reader.ReadString();
			if (text != GetType().Name)
			{
				throw new InvalidDataException("Mismatched optimizer type: expected '" + GetType().Name + "', but found '" + text + "' in the loaded stream.");
			}
			long num = reader.Decode();
			long num2 = reader.Decode();
			StateDictionary stateDictionary = state_dict();
			if (num != stateDictionary.Options.Count)
			{
				throw new ArgumentException("Invalid optimizer state -- different number of parameter groups.");
			}
			if (num2 != stateDictionary.State.Count)
			{
				throw new ArgumentException("Invalid optimizer state -- different number of states.");
			}
			for (int i = 0; i < num; i++)
			{
				stateDictionary.Options[i].LoadStateDict(reader);
			}
			for (int j = 0; j < num2; j++)
			{
				stateDictionary.State[j].LoadStateDict(reader);
			}
		}

		public virtual void load_state_dict(StateDictionary state_dict)
		{
			StateDictionary stateDictionary = this.state_dict();
			if (state_dict.Options.Count != stateDictionary.Options.Count)
			{
				throw new ArgumentException("Invalid optimizer state -- different number of parameter groups.");
			}
			if (state_dict.State.Count != stateDictionary.State.Count)
			{
				throw new ArgumentException("Invalid optimizer state -- different number of states.");
			}
			for (int i = 0; i < state_dict.Options.Count; i++)
			{
				OptimizerOptions optimizerOptions = stateDictionary.Options[i];
				if (optimizerOptions != state_dict.Options[i])
				{
					optimizerOptions.LoadStateDict(state_dict.Options[i]);
				}
			}
			for (int j = 0; j < state_dict.State.Count; j++)
			{
				OptimizerState optimizerState = stateDictionary.State[j];
				if (optimizerState != state_dict.State[j])
				{
					optimizerState.LoadStateDict(state_dict.State[j]);
				}
			}
		}

		public virtual StateDictionary state_dict()
		{
			StateDictionary stateDictionary = new StateDictionary();
			int num = -1;
			int num2 = 0;
			foreach (ParamGroup parameter_group in _parameter_groups)
			{
				stateDictionary.Options.Add(parameter_group.Options);
				List<int> list = new List<int>();
				stateDictionary.StateIndexRef.Add(list);
				foreach (Parameter parameter in parameter_group.Parameters)
				{
					list.Add(num2);
					stateDictionary.State.Add(_state[parameter.Handle]);
					num2++;
				}
				num--;
			}
			return stateDictionary;
		}

		public void to(torch.Device device)
		{
			foreach (ParamGroup parameter_group in _parameter_groups)
			{
				foreach (Parameter parameter in parameter_group.Parameters)
				{
					_state[parameter.Handle].to(device);
				}
			}
		}

		public override void zero_grad()
		{
			foreach (ParamGroup parameter_group in _parameter_groups)
			{
				foreach (Parameter parameter in parameter_group.Parameters)
				{
					using torch.Tensor tensor = parameter.grad;
					tensor?.zero_();
				}
			}
		}

		protected torch.Tensor _step<T>(Action<T> body, Func<torch.Tensor> loss_closure = null) where T : ParamGroup
		{
			torch.Tensor result = null;
			if (loss_closure != null)
			{
				using (torch.enable_grad())
				{
					result = loss_closure();
				}
			}
			using (torch.no_grad())
			{
				using (torch.NewDisposeScope())
				{
					foreach (ParamGroup parameter_group in _parameter_groups)
					{
						body(parameter_group as T);
					}
					return result;
				}
			}
		}

		public override IEnumerable<Parameter> parameters()
		{
			return _parameter_groups.SelectMany((ParamGroup pg) => pg.Parameters);
		}

		public override void add_param_group(ParamGroup param_group)
		{
			_parameter_groups.Add(param_group);
		}
	}
	public class OptimizerOptions
	{
		public double? LearningRate { get; set; }

		public double InitialLearningRate { get; set; }

		public virtual void SaveStateDict(BinaryWriter writer)
		{
			writer.Write(InitialLearningRate);
			writer.Write(LearningRate.Value);
		}

		public virtual void LoadStateDict(BinaryReader reader)
		{
			InitialLearningRate = reader.ReadDouble();
			LearningRate = reader.ReadDouble();
		}

		public virtual void LoadStateDict(OptimizerOptions source)
		{
			InitialLearningRate = source.InitialLearningRate;
			LearningRate = source.LearningRate;
		}
	}
	public abstract class OptimizerState
	{
		protected Parameter _parameter;

		protected OptimizerState(Parameter parameter)
		{
			_parameter = parameter;
		}

		public abstract void SaveStateDict(BinaryWriter writer);

		public abstract void LoadStateDict(BinaryReader reader);

		public abstract void LoadStateDict(OptimizerState source);

		public virtual bool ApproximatelyEquals(OptimizerState other)
		{
			return false;
		}

		public abstract void Initialize(OptimizerOptions options);

		public virtual void to(torch.Device device)
		{
		}

		protected static void LoadConditionalStateTensor(BinaryReader reader, ref torch.Tensor result, torch.Device device)
		{
			if (reader.ReadBoolean())
			{
				TensorExtensionMethods.Load(ref result, reader);
				result = result.to(device, copy: false, disposeAfter: true);
				return;
			}
			if ((object)result != null)
			{
				result.Dispose();
			}
			result = null;
		}

		protected static void SaveConditionalStateTensor(BinaryWriter writer, torch.Tensor tensor)
		{
			if ((object)tensor != null)
			{
				writer.Write(value: true);
				tensor.Save(writer);
			}
			else
			{
				writer.Write(value: false);
			}
		}
	}
	public class ParamGroup : torch.optim.ILearningRateController
	{
		public IEnumerable<Parameter> Parameters { get; set; }

		public OptimizerOptions Options { get; set; }

		public double LearningRate
		{
			get
			{
				return Options.LearningRate.Value;
			}
			set
			{
				Options.LearningRate = value;
			}
		}

		public double InitialLearningRate
		{
			get
			{
				return Options.InitialLearningRate;
			}
			set
			{
				Options.InitialLearningRate = value;
			}
		}
	}
	public class ParamGroup<TOptions> : ParamGroup where TOptions : OptimizerOptions
	{
		public new TOptions Options
		{
			get
			{
				return (TOptions)base.Options;
			}
			set
			{
				base.Options = value;
			}
		}

		public ParamGroup()
		{
		}

		public ParamGroup(IEnumerable<Parameter> parameters, TOptions options = null)
		{
			base.Parameters = parameters;
			base.Options = options;
		}
	}
	public class RAdam : OptimizerHelper, torch.optim.IBetas
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor exp_avg;

			public torch.Tensor exp_avg_sq;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					exp_avg.Dispose();
					exp_avg_sq.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				exp_avg = exp_avg.to(device);
				exp_avg_sq = exp_avg_sq.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(exp_avg, reader);
				TensorExtensionMethods.Load(exp_avg_sq, reader);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				exp_avg.Save(writer);
				exp_avg_sq.Save(writer);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				exp_avg.Dispose();
				exp_avg_sq.Dispose();
				step = state.step;
				exp_avg = state.exp_avg.to(_parameter.device, copy: true);
				exp_avg_sq = state.exp_avg_sq.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && exp_avg.allclose(state.exp_avg))
				{
					return exp_avg_sq.allclose(state.exp_avg_sq);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				exp_avg?.Dispose();
				exp_avg_sq?.Dispose();
				step = 0L;
				exp_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				exp_avg_sq = torch.zeros_like(_parameter).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public double? beta1;

			public double? beta2;

			public double? eps;

			public double? weight_decay;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				beta1 = options.beta1;
				beta2 = options.beta2;
				eps = options.eps;
				weight_decay = options.weight_decay;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				beta1 = reader.ReadDouble();
				beta2 = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(beta1.Value);
				writer.Write(beta2.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IBetas
		{
			public (double, double) Betas
			{
				get
				{
					return (base.Options.beta1.Value, base.Options.beta2.Value);
				}
				set
				{
					base.Options.beta1 = value.Item1;
					base.Options.beta2 = value.Item2;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 1.0, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
				: base(parameters, new Options
				{
					LearningRate = lr,
					beta1 = beta1,
					beta2 = beta2,
					eps = eps,
					weight_decay = weight_decay
				})
			{
			}
		}

		public (double, double) Betas
		{
			get
			{
				return ((_defaults as Options).beta1.Value, (_defaults as Options).beta2.Value);
			}
			set
			{
				(_defaults as Options).beta1 = value.Item1;
				(_defaults as Options).beta2 = value.Item2;
			}
		}

		public RAdam(IEnumerable<Parameter> parameters, double lr, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, beta1, beta2, eps, weight_decay)
		{
		}

		public RAdam(IEnumerable<ParamGroup> parameters, double lr = 0.002, double beta1 = 0.9, double beta2 = 0.999, double eps = 1E-08, double weight_decay = 0.0)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (beta1 < 0.0 || beta1 > 1.0)
			{
				throw new ArgumentException($"Invalid beta1 value: {beta1}");
			}
			if (beta2 < 0.0 || beta2 > 1.0)
			{
				throw new ArgumentException($"Invalid beta2 value: {beta2}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid eps value: {eps}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				beta1 = beta1,
				beta2 = beta2,
				eps = eps,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.beta1.Value;
				double value2 = options.beta2.Value;
				double value3 = options.eps.Value;
				double value4 = options.weight_decay.Value;
				double value5 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					torch.Tensor grad = parameter.grad;
					if ((object)grad != null)
					{
						State state = (State)_state[parameter.handle];
						state.step++;
						torch.Tensor exp_avg = state.exp_avg;
						torch.Tensor exp_avg_sq = state.exp_avg_sq;
						double num = 1.0 - Math.Pow(value, state.step);
						double num2 = 1.0 - Math.Pow(value2, state.step);
						grad = ((value4 != 0.0) ? grad.add(parameter, value4) : grad.alias());
						exp_avg.mul_(value).add_(grad, 1.0 - value);
						exp_avg_sq.mul_(value2).addcmul_(grad, grad, 1.0 - value2);
						torch.Tensor tensor = exp_avg / num;
						double num3 = 2.0 / (1.0 - value2) - 1.0;
						double num4 = num3 - (double)(2 * state.step) * Math.Pow(value2, state.step) / num2;
						torch.Tensor tensor2 = tensor * value5;
						if (num4 > 5.0)
						{
							double num5 = Math.Sqrt((num4 - 4.0) * (num4 - 2.0) * num3 / ((num3 - 4.0) * (num3 - 2.0) * num4));
							torch.Tensor tensor3 = Math.Sqrt(num2) / exp_avg_sq.sqrt().add_(value3);
							parameter.add_(tensor2 * value5 * tensor3 * num5, -1.0);
						}
						else
						{
							parameter.add_(tensor2, -1.0);
						}
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.beta1.HasValue)
			{
				options2.beta1 = options.beta1;
			}
			if (!options2.beta2.HasValue)
			{
				options2.beta2 = options.beta2;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class RMSProp : OptimizerHelper, torch.optim.IMomentum
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor square_avg;

			public torch.Tensor momentum_buffer;

			public torch.Tensor grad_avg;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					momentum_buffer?.Dispose();
					square_avg.Dispose();
					grad_avg?.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				square_avg = square_avg.to(device);
				momentum_buffer = momentum_buffer?.to(device);
				grad_avg = grad_avg?.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(square_avg, reader);
				OptimizerState.LoadConditionalStateTensor(reader, ref momentum_buffer, _parameter.device);
				OptimizerState.LoadConditionalStateTensor(reader, ref grad_avg, _parameter.device);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				square_avg.Save(writer);
				OptimizerState.SaveConditionalStateTensor(writer, momentum_buffer);
				OptimizerState.SaveConditionalStateTensor(writer, grad_avg);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				square_avg.Dispose();
				grad_avg.Dispose();
				momentum_buffer.Dispose();
				step = state.step;
				square_avg = state.square_avg.to(_parameter.device, copy: true);
				grad_avg = state.grad_avg.to(_parameter.device, copy: true);
				momentum_buffer = state.momentum_buffer.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && square_avg.allclose(state.square_avg) && grad_avg.allclose(state.grad_avg))
				{
					return momentum_buffer.allclose(state.momentum_buffer);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				square_avg?.Dispose();
				grad_avg?.Dispose();
				momentum_buffer?.Dispose();
				step = 0L;
				square_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				grad_avg = torch.zeros_like(_parameter).DetachFromDisposeScope();
				momentum_buffer = torch.zeros_like(_parameter).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public bool? maximize;

			public double? momentum;

			public double? alpha;

			public double? eps;

			public double? weight_decay;

			public bool? centered;

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				maximize = options.maximize;
				momentum = options.momentum;
				alpha = options.alpha;
				weight_decay = options.weight_decay;
				eps = options.eps;
				centered = options.centered;
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				maximize = reader.ReadBoolean();
				momentum = reader.ReadDouble();
				alpha = reader.ReadDouble();
				eps = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				centered = reader.ReadBoolean();
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(maximize.Value);
				writer.Write(momentum.Value);
				writer.Write(alpha.Value);
				writer.Write(eps.Value);
				writer.Write(weight_decay.Value);
				writer.Write(centered.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IMomentum
		{
			public double Momentum
			{
				get
				{
					return base.Options.momentum.Value;
				}
				set
				{
					base.Options.momentum = value;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.001, double eps = 1E-08, double alpha = 0.99, double weight_decay = 0.0, double momentum = 0.0, bool centered = false)
				: base(parameters, new Options
				{
					LearningRate = lr,
					eps = eps,
					alpha = alpha,
					weight_decay = weight_decay,
					momentum = momentum,
					centered = centered
				})
			{
			}
		}

		public double Momentum
		{
			get
			{
				return (_defaults as Options).momentum.Value;
			}
			set
			{
				(_defaults as Options).momentum = value;
			}
		}

		public RMSProp(IEnumerable<Parameter> parameters, double lr = 0.001, double alpha = 0.99, double eps = 1E-08, double weight_decay = 0.0, double momentum = 0.0, bool centered = false, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, alpha, eps, weight_decay, momentum, centered, maximize)
		{
		}

		public RMSProp(IEnumerable<ParamGroup> parameters, double lr = 0.001, double alpha = 0.99, double eps = 1E-08, double weight_decay = 0.0, double momentum = 0.0, bool centered = false, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (eps < 0.0)
			{
				throw new ArgumentException($"Invalid ε: {eps}");
			}
			if (alpha < 0.0)
			{
				throw new ArgumentException($"Invalid alpha: {alpha}");
			}
			if (momentum < 0.0)
			{
				throw new ArgumentException($"Invalid momentum value: {momentum}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				maximize = maximize,
				eps = eps,
				alpha = alpha,
				momentum = momentum,
				centered = centered,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				bool value = options.maximize.Value;
				double value2 = options.momentum.Value;
				double value3 = options.alpha.Value;
				double value4 = options.weight_decay.Value;
				bool value5 = options.centered.Value;
				double value6 = options.eps.Value;
				double value7 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					State state = (State)_state[parameter.handle];
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (value)
						{
							tensor = -tensor;
						}
						state.step++;
						if (value4 != 0.0)
						{
							tensor = tensor.add(parameter, value4);
						}
						state.square_avg.mul_(value3).addcmul_(tensor, tensor, 1.0 - value3);
						torch.Tensor tensor2 = null;
						if (value5)
						{
							torch.Tensor grad_avg = state.grad_avg;
							grad_avg.mul_(value3).add_(tensor, 1.0 - value3);
							tensor2 = state.square_avg.addcmul(grad_avg, grad_avg, -1).sqrt_().add_(value6);
						}
						else
						{
							tensor2 = state.square_avg.sqrt().add_(value6);
						}
						if (value2 > 0.0)
						{
							torch.Tensor momentum_buffer = state.momentum_buffer;
							momentum_buffer.mul_(value2).addcdiv_(tensor, tensor2);
							parameter.add_(momentum_buffer, 0.0 - value7);
						}
						else
						{
							parameter.addcdiv_(tensor, tensor2, 0.0 - value7);
						}
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
			_state.Clear();
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.momentum.HasValue)
			{
				options2.momentum = options.momentum;
			}
			if (!options2.eps.HasValue)
			{
				options2.eps = options.eps;
			}
			if (!options2.alpha.HasValue)
			{
				options2.alpha = options.alpha;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.centered.HasValue)
			{
				options2.centered = options.centered;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class Rprop : OptimizerHelper
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public long step;

			public torch.Tensor prev;

			public torch.Tensor step_size;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					prev.Dispose();
					step_size.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				prev = prev.to(device);
				step_size = step_size.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				step = reader.ReadInt64();
				TensorExtensionMethods.Load(prev, reader);
				TensorExtensionMethods.Load(step_size, reader);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				writer.Write(step);
				prev.Save(writer);
				step_size.Save(writer);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				prev.Dispose();
				step_size.Dispose();
				step = state.step;
				prev = state.prev.to(_parameter.device, copy: true);
				step_size = state.step_size.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state && step == state.step && prev.allclose(state.prev))
				{
					return step_size.allclose(state.step_size);
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				prev?.Dispose();
				step_size?.Dispose();
				step = 0L;
				prev = torch.zeros_like(_parameter).DetachFromDisposeScope();
				torch.Tensor tensor = _parameter.new_empty(_parameter.shape);
				double? learningRate = (options as Options).LearningRate;
				step_size = tensor.fill_(learningRate.HasValue ? ((Scalar)learningRate.GetValueOrDefault()) : null).DetachFromDisposeScope();
			}
		}

		public class Options : OptimizerOptions
		{
			public bool? maximize;

			public double? etaminus;

			public double? etaplus;

			public double? min_step;

			public double? max_step;

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(maximize.Value);
				writer.Write(etaminus.Value);
				writer.Write(etaplus.Value);
				writer.Write(min_step.Value);
				writer.Write(max_step.Value);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				maximize = reader.ReadBoolean();
				etaminus = reader.ReadDouble();
				etaplus = reader.ReadDouble();
				min_step = reader.ReadDouble();
				max_step = reader.ReadDouble();
			}

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				maximize = options.maximize;
				etaminus = options.etaminus;
				etaplus = options.etaplus;
				min_step = options.min_step;
				max_step = options.max_step;
			}
		}

		public class ParamGroup : ParamGroup<Options>
		{
			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.01, double etaminus = 0.5, double etaplus = 1.2, double min_step = 1E-06, double max_step = 50.0, bool maximize = false)
				: base(parameters, new Options
				{
					LearningRate = lr,
					etaminus = etaminus,
					etaplus = etaplus,
					min_step = min_step,
					max_step = max_step,
					maximize = maximize
				})
			{
			}
		}

		public Rprop(IEnumerable<Parameter> parameters, double lr = 0.01, double etaminus = 0.5, double etaplus = 1.2, double min_step = 1E-06, double max_step = 50.0, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, etaminus, etaplus, min_step, max_step, maximize)
		{
		}

		public Rprop(IEnumerable<ParamGroup> parameters, double lr = 0.01, double etaminus = 0.5, double etaplus = 1.2, double min_step = 1E-06, double max_step = 50.0, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				maximize = maximize,
				etaminus = etaminus,
				etaplus = etaplus,
				min_step = min_step,
				max_step = max_step
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				bool value = options.maximize.Value;
				double value2 = options.etaminus.Value;
				double value3 = options.etaplus.Value;
				double value4 = options.min_step.Value;
				double value5 = options.max_step.Value;
				_ = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (tensor.is_sparse)
						{
							throw new ArgumentException("Rprop does not support sparse gradients");
						}
						if (value)
						{
							tensor = -tensor;
						}
						State state = (State)_state[parameter.handle];
						state.step++;
						torch.Tensor tensor2 = tensor.mul(state.prev).sign();
						tensor2[new torch.Tensor[1] { tensor2.gt(0) }] = value3;
						tensor2[new torch.Tensor[1] { tensor2.lt(0) }] = value2;
						tensor2[new torch.Tensor[1] { tensor2.eq(0) }] = 1;
						state.step_size.mul_(tensor2).clamp_(value4, value5);
						tensor = tensor.clone();
						tensor.index_put_(0, tensor2.eq(value2));
						parameter.addcmul_(tensor.sign(), state.step_size, -1);
						state.prev.copy_(tensor);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				((State)item.Item2).Dispose();
			}
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.etaminus.HasValue)
			{
				options2.etaminus = options.etaminus;
			}
			if (!options2.etaplus.HasValue)
			{
				options2.etaplus = options.etaplus;
			}
			if (!options2.min_step.HasValue)
			{
				options2.min_step = options.min_step;
			}
			if (!options2.max_step.HasValue)
			{
				options2.max_step = options.max_step;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class SGD : OptimizerHelper, torch.optim.IMomentum
	{
		public sealed class State : OptimizerState, IDisposable
		{
			public torch.Tensor momentum_buffer;

			public State(Parameter parameter)
				: base(parameter)
			{
			}

			public void Dispose()
			{
				Dispose(disposing: true);
				GC.SuppressFinalize(this);
			}

			private void Dispose(bool disposing)
			{
				if (disposing)
				{
					momentum_buffer?.Dispose();
				}
			}

			public override void to(torch.Device device)
			{
				momentum_buffer = momentum_buffer?.to(device);
			}

			public override void LoadStateDict(BinaryReader reader)
			{
				OptimizerState.LoadConditionalStateTensor(reader, ref momentum_buffer, _parameter.device);
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				OptimizerState.SaveConditionalStateTensor(writer, momentum_buffer);
			}

			public override void LoadStateDict(OptimizerState source)
			{
				State state = source as State;
				momentum_buffer?.Dispose();
				momentum_buffer = state.momentum_buffer.to(_parameter.device, copy: true);
			}

			public override bool ApproximatelyEquals(OptimizerState other)
			{
				if (other is State state)
				{
					if ((object)momentum_buffer != null)
					{
						return momentum_buffer.allclose(state.momentum_buffer);
					}
					return true;
				}
				return false;
			}

			public override void Initialize(OptimizerOptions options)
			{
				momentum_buffer?.Dispose();
				momentum_buffer = null;
			}
		}

		public class Options : OptimizerOptions
		{
			public double? momentum;

			public double? dampening;

			public double? weight_decay;

			public bool? nesterov;

			public bool? maximize;

			public override void LoadStateDict(BinaryReader reader)
			{
				base.LoadStateDict(reader);
				momentum = reader.ReadDouble();
				dampening = reader.ReadDouble();
				weight_decay = reader.ReadDouble();
				nesterov = reader.ReadBoolean();
				maximize = reader.ReadBoolean();
			}

			public override void LoadStateDict(OptimizerOptions source)
			{
				base.LoadStateDict(source);
				Options options = source as Options;
				momentum = options.momentum;
				dampening = options.dampening;
				weight_decay = options.weight_decay;
				nesterov = options.nesterov;
				maximize = options.maximize;
			}

			public override void SaveStateDict(BinaryWriter writer)
			{
				base.SaveStateDict(writer);
				writer.Write(momentum.Value);
				writer.Write(dampening.Value);
				writer.Write(weight_decay.Value);
				writer.Write(nesterov.Value);
				writer.Write(maximize.Value);
			}
		}

		public class ParamGroup : ParamGroup<Options>, torch.optim.IMomentum
		{
			public double Momentum
			{
				get
				{
					return base.Options.momentum.Value;
				}
				set
				{
					base.Options.momentum = value;
				}
			}

			public ParamGroup()
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, Options options)
				: base(parameters, options)
			{
			}

			public ParamGroup(IEnumerable<Parameter> parameters, double lr = 0.001, double momentum = 0.0, double dampening = 0.0, double weight_decay = 0.0, bool nesterov = false, bool maximize = false)
				: base(parameters, new Options
				{
					LearningRate = lr,
					dampening = dampening,
					momentum = momentum,
					weight_decay = weight_decay,
					nesterov = nesterov,
					maximize = maximize
				})
			{
			}
		}

		public double Momentum
		{
			get
			{
				return (_defaults as Options).momentum.Value;
			}
			set
			{
				(_defaults as Options).momentum = value;
			}
		}

		public SGD(IEnumerable<Parameter> parameters, double lr, double momentum = 0.0, double dampening = 0.0, double weight_decay = 0.0, bool nesterov = false, bool maximize = false)
			: this(new ParamGroup[1]
			{
				new ParamGroup
				{
					Parameters = parameters
				}
			}, lr, momentum, dampening, weight_decay, nesterov, maximize)
		{
		}

		public SGD(IEnumerable<ParamGroup> parameters, double lr, double momentum = 0.0, double dampening = 0.0, double weight_decay = 0.0, bool nesterov = false, bool maximize = false)
		{
			if (lr < 0.0)
			{
				throw new ArgumentException($"Invalid learning rate: {lr}");
			}
			if (momentum < 0.0)
			{
				throw new ArgumentException($"Invalid momentum value: {momentum}");
			}
			if (weight_decay < 0.0)
			{
				throw new ArgumentException($"Invalid weight_decay value: {weight_decay}");
			}
			if (nesterov && (momentum <= 0.0 || dampening != 0.0))
			{
				throw new ArgumentException("Nesterov momentum requires a momentum and zero dampening");
			}
			Options defaults = new Options
			{
				LearningRate = lr,
				InitialLearningRate = lr,
				dampening = dampening,
				maximize = maximize,
				momentum = momentum,
				nesterov = nesterov,
				weight_decay = weight_decay
			};
			_defaults = defaults;
			_parameter_groups = new List<TorchSharp.Modules.ParamGroup>();
			foreach (ParamGroup parameter in parameters)
			{
				add_param_group(parameter);
			}
		}

		public override torch.Tensor step(Func<torch.Tensor> closure = null)
		{
			return _step(delegate(ParamGroup group)
			{
				Options options = group.Options;
				double value = options.momentum.Value;
				double value2 = options.dampening.Value;
				double value3 = options.weight_decay.Value;
				bool value4 = options.nesterov.Value;
				bool value5 = options.maximize.Value;
				double value6 = options.LearningRate.Value;
				foreach (Parameter parameter in group.Parameters)
				{
					State state = (State)_state[parameter.handle];
					torch.Tensor tensor = parameter.grad;
					if ((object)tensor != null)
					{
						if (value3 != 0.0)
						{
							tensor = tensor.add(parameter, value3);
						}
						if (value != 0.0)
						{
							torch.Tensor tensor2 = state.momentum_buffer;
							if ((object)tensor2 == null)
							{
								tensor2 = (state.momentum_buffer = tensor.clone().detach().DetachFromDisposeScope());
							}
							else
							{
								tensor2.mul_(value).add_(tensor, 1.0 - value2);
							}
							tensor = ((!value4) ? tensor2 : tensor.add(tensor2, value));
							state.momentum_buffer = tensor2;
						}
						double num = (value5 ? value6 : (0.0 - value6));
						parameter.add_(tensor, num);
					}
				}
			}, closure);
		}

		protected override void Dispose(bool disposing)
		{
			base.Dispose(disposing);
			foreach (var item in _state)
			{
				State state = (State)item.Item2;
				if ((object)state.momentum_buffer != null)
				{
					state.momentum_buffer.Dispose();
				}
			}
			_state.Clear();
		}

		public override void add_param_group(TorchSharp.Modules.ParamGroup param_group)
		{
			Options options = _defaults as Options;
			if (param_group.Options == null)
			{
				param_group.Options = new Options();
			}
			Options options2 = param_group.Options as Options;
			if (!options2.LearningRate.HasValue)
			{
				options2.LearningRate = options.LearningRate;
			}
			if (!options2.momentum.HasValue)
			{
				options2.momentum = options.momentum;
			}
			if (!options2.dampening.HasValue)
			{
				options2.dampening = options.dampening;
			}
			if (!options2.weight_decay.HasValue)
			{
				options2.weight_decay = options.weight_decay;
			}
			if (!options2.nesterov.HasValue)
			{
				options2.nesterov = options.nesterov;
			}
			if (!options2.maximize.HasValue)
			{
				options2.maximize = options.maximize;
			}
			options2.InitialLearningRate = options2.LearningRate.Value;
			_parameter_groups.Add(param_group);
			foreach (Parameter parameter in param_group.Parameters)
			{
				State state = new State(parameter);
				_state[parameter.Handle] = state;
				state.Initialize(options2);
			}
		}
	}
	public class SummaryWriter
	{
		private string _log_dir;

		private Dictionary<string, string> _fileNames = new Dictionary<string, string>();

		private string _suffix;

		private int _global_uid;

		public string LogDir => _log_dir;

		internal SummaryWriter(string log_dir, string filename_suffix)
		{
			_suffix = filename_suffix;
			if (string.IsNullOrEmpty(log_dir))
			{
				_log_dir = torch.utils.tensorboard.CreateRunName("runs");
			}
			else
			{
				_log_dir = log_dir;
			}
			if (!Directory.Exists(_log_dir))
			{
				Directory.CreateDirectory(_log_dir);
			}
			string text = Path.Combine(_log_dir, $"events.out.tfevents.{DateTime.Now.Ticks}.{Dns.GetHostName()}.{Process.GetCurrentProcess().Id}.{Interlocked.Increment(ref _global_uid)}");
			if (!string.IsNullOrEmpty(_suffix))
			{
				text = text + "." + _suffix;
			}
			if (File.Exists(text))
			{
				File.Delete(text);
			}
			InitFile(text);
			_fileNames["__default__"] = text;
		}

		public void add_scalar(string tag, float scalar_value, int global_step, long? walltime = null)
		{
			string fileName = InitDefaultFile();
			SetWalltime(ref walltime);
			Summary summary = new Summary();
			summary.Value.Add(new Summary.Types.Value
			{
				SimpleValue = scalar_value,
				Tag = tag
			});
			Event evnt = new Event
			{
				Step = global_step,
				WallTime = walltime.Value,
				Summary = summary
			};
			WriteEvent(fileName, evnt);
		}

		public void add_scalars(string main_tag, IDictionary<string, float> tag_scalar_dict, int global_step, long? walltime = null)
		{
			SetWalltime(ref walltime);
			foreach (KeyValuePair<string, float> item in tag_scalar_dict)
			{
				string key = item.Key;
				float value = item.Value;
				Summary summary = new Summary();
				summary.Value.Add(new Summary.Types.Value
				{
					SimpleValue = value,
					Tag = main_tag
				});
				Event evnt = new Event
				{
					Step = global_step,
					WallTime = walltime.Value,
					Summary = summary
				};
				if (!_fileNames.TryGetValue(key, out var value2))
				{
					string text = Path.Combine(_log_dir, main_tag + "_" + key);
					if (!Directory.Exists(text))
					{
						Directory.CreateDirectory(text);
					}
					value2 = Path.Combine(text, $"events.out.tfevents.{DateTime.Now.Ticks}.{Dns.GetHostName()}.{Process.GetCurrentProcess().Id}.{Interlocked.Increment(ref _global_uid)}");
					if (File.Exists(value2))
					{
						File.Delete(value2);
					}
					InitFile(value2);
					_fileNames[key] = value2;
				}
				WriteEvent(value2, evnt);
			}
		}

		public void add_scalars(string main_tag, IList<(string, float)> tag_scalar_dict, int global_step, long? walltime = null)
		{
			SetWalltime(ref walltime);
			foreach (var item3 in tag_scalar_dict)
			{
				string item = item3.Item1;
				float item2 = item3.Item2;
				Summary summary = new Summary();
				summary.Value.Add(new Summary.Types.Value
				{
					SimpleValue = item2,
					Tag = main_tag
				});
				Event evnt = new Event
				{
					Step = global_step,
					WallTime = walltime.Value,
					Summary = summary
				};
				if (!_fileNames.TryGetValue(item, out var value))
				{
					string text = Path.Combine(_log_dir, main_tag + "_" + item);
					if (!Directory.Exists(text))
					{
						Directory.CreateDirectory(text);
					}
					value = Path.Combine(text, $"events.out.tfevents.{DateTime.Now.Ticks}.{Dns.GetHostName()}.{Process.GetCurrentProcess().Id}.{Interlocked.Increment(ref _global_uid)}");
					if (!File.Exists(value))
					{
						InitFile(value);
					}
					_fileNames[item] = value;
				}
				WriteEvent(value, evnt);
			}
		}

		public void add_histogram(string tag, torch.Tensor values, int global_step, TorchSharp.Utils.tensorboard.Enums.HistogramBinSelector bins = TorchSharp.Utils.tensorboard.Enums.HistogramBinSelector.Tensorflow, long? walltime = null, long? max_bins = null)
		{
			string fileName = InitDefaultFile();
			SetWalltime(ref walltime);
			Summary summary = ((bins == TorchSharp.Utils.tensorboard.Enums.HistogramBinSelector.Tensorflow) ? torch.utils.tensorboard.Summary.histogram(tag, values, default_bins(), max_bins) : torch.utils.tensorboard.Summary.histogram(tag, values, (HistogramBinSelector)bins, max_bins));
			Event evnt = new Event
			{
				Step = global_step,
				WallTime = walltime.Value,
				Summary = summary
			};
			WriteEvent(fileName, evnt);
			static torch.Tensor default_bins()
			{
				double num = 1E-12;
				List<double> list = new List<double>();
				List<double> list2 = new List<double>();
				while (num < 1E+20)
				{
					list.Add(num);
					list2.Add(0.0 - num);
					num *= 1.1;
				}
				list2.Reverse();
				List<double> list3 = new List<double>();
				list3.AddRange(list2);
				list3.Add(0.0);
				list3.AddRange(list);
				return torch.tensor(list3);
			}
		}

		public void add_img(string tag, torch.Tensor img_tensor, int global_step, long? walltime = null, string dataformats = "CHW")
		{
			string fileName = InitDefaultFile();
			SetWalltime(ref walltime);
			Summary summary = torch.utils.tensorboard.Summary.image(tag, img_tensor, 1.0, dataformats);
			Event evnt = new Event
			{
				Step = global_step,
				WallTime = walltime.Value,
				Summary = summary
			};
			WriteEvent(fileName, evnt);
		}

		public void add_img(string tag, string file_name, int global_step, long? walltime = null)
		{
			string fileName = InitDefaultFile();
			SetWalltime(ref walltime);
			Summary summary = torch.utils.tensorboard.Summary.image(tag, file_name);
			Event evnt = new Event
			{
				Step = global_step,
				WallTime = walltime.Value,
				Summary = summary
			};
			WriteEvent(fileName, evnt);
		}

		public void add_video(string tag, torch.Tensor vid_tensor, int global_step, int fps = 4, long? walltime = null)
		{
			string fileName = InitDefaultFile();
			SetWalltime(ref walltime);
			Summary summary = torch.utils.tensorboard.Summary.video(tag, vid_tensor, fps);
			Event evnt = new Event
			{
				Step = global_step,
				WallTime = walltime.Value,
				Summary = summary
			};
			WriteEvent(fileName, evnt);
		}

		public void add_text(string tag, string text_string, int global_step, long? walltime = null)
		{
			string fileName = InitDefaultFile();
			SetWalltime(ref walltime);
			Event evnt = new Event
			{
				Step = global_step,
				WallTime = walltime.Value,
				Summary = torch.utils.tensorboard.Summary.text(tag, text_string)
			};
			WriteEvent(fileName, evnt);
		}

		private static void InitFile(string fileName)
		{
			Event evnt = new Event
			{
				FileVersion = "brain.Event:2",
				WallTime = DateTime.Now.Ticks
			};
			WriteEvent(fileName, evnt);
		}

		private string InitDefaultFile()
		{
			string text = _fileNames["__default__"];
			if (!File.Exists(text))
			{
				InitFile(text);
			}
			return text;
		}

		private static void SetWalltime(ref long? walltime)
		{
			long valueOrDefault = walltime.GetValueOrDefault();
			if (!walltime.HasValue)
			{
				valueOrDefault = DateTimeOffset.Now.ToUnixTimeSeconds();
				walltime = valueOrDefault;
			}
		}

		private static void WriteEvent(string fileName, Event evnt)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			byte[] array = MessageExtensions.ToByteArray((IMessage)(object)evnt);
			long num = array.LongLength;
			uint maskedCrc = GetMaskedCrc(num);
			uint maskedCrc2 = GetMaskedCrc(array);
			using FileStream fileStream = File.Open(fileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read);
			fileStream.Seek(0L, SeekOrigin.End);
			using BinaryWriter binaryWriter = new BinaryWriter(fileStream);
			binaryWriter.Write(num);
			binaryWriter.Write(maskedCrc);
			CodedOutputStream val = new CodedOutputStream((Stream)fileStream, true);
			try
			{
				evnt.WriteTo(val);
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
			fileStream.Seek(0L, SeekOrigin.End);
			binaryWriter.Write(maskedCrc2);
			fileStream.Flush();
		}

		private static uint GetMaskedCrc(byte[] data)
		{
			uint num = CRC32C.process(data);
			return ((num >> 15) | (num << 17)) + 2726488792u;
		}

		private static uint GetMaskedCrc(int data)
		{
			uint num = CRC32C.process(data);
			return ((num >> 15) | (num << 17)) + 2726488792u;
		}

		private static uint GetMaskedCrc(long data)
		{
			uint num = CRC32C.process(data);
			return ((num >> 15) | (num << 17)) + 2726488792u;
		}
	}
	public class TensorDataset : torch.utils.data.IterableDataset
	{
		private readonly torch.Tensor[] _tensors;

		public IList<torch.Tensor> this[long index] => _tensors.Select((torch.Tensor t) => t[index]).ToList();

		public override long Count => _tensors[0].size(0);

		internal TensorDataset(torch.Tensor[] tensors)
		{
			if (tensors == null || tensors.Length == 0)
			{
				throw new ArgumentNullException("tensors");
			}
			long size1 = tensors[0].shape[0];
			if (!tensors.All((torch.Tensor t) => t.shape[0] == size1))
			{
				throw new ArgumentException("All tensors must have the same first dimension size.", "tensors");
			}
			_tensors = tensors.Select((torch.Tensor x) => x.alias().DetachFromDisposeScope()).ToArray();
		}

		public override IList<torch.Tensor> GetTensor(long index)
		{
			return this[index];
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing)
			{
				torch.Tensor[] tensors = _tensors;
				for (int i = 0; i < tensors.Length; i++)
				{
					tensors[i].Dispose();
				}
			}
		}
	}
}
namespace TorchSharp.Data
{
	public class DataIterator : IDisposable, IEnumerable<(torch.Tensor data, torch.Tensor target)>, IEnumerable
	{
		protected sealed class HType : SafeHandle
		{
			public override bool IsInvalid => handle == IntPtr.Zero;

			public HType(IntPtr preexistingHandle, bool ownsHandle)
				: base(IntPtr.Zero, ownsHandle)
			{
				SetHandle(preexistingHandle);
			}

			internal HType()
				: base(IntPtr.Zero, ownsHandle: true)
			{
			}

			protected override bool ReleaseHandle()
			{
				return true;
			}

			protected override void Dispose(bool disposing)
			{
				if (disposing)
				{
					ReleaseHandle();
				}
			}
		}

		private class DataIteratorEnumerator : IEnumerator<(torch.Tensor data, torch.Tensor target)>, IEnumerator, IDisposable
		{
			private DataIterator _iterator;

			private readonly PinnedArray<IntPtr> _darray = new PinnedArray<IntPtr>();

			private readonly PinnedArray<IntPtr> _tarray = new PinnedArray<IntPtr>();

			private readonly IntPtr _dRef;

			private readonly IntPtr _tRef;

			private bool _isFirst = true;

			public (torch.Tensor data, torch.Tensor target) Current
			{
				get
				{
					NativeMethods.THSData_current(_iterator.handle.DangerousGetHandle(), _dRef, _tRef);
					return (data: new torch.Tensor(_darray.Array[0]), target: new torch.Tensor(_tarray.Array[0]));
				}
			}

			object IEnumerator.Current => Current;

			public DataIteratorEnumerator(DataIterator iterator)
			{
				_iterator = iterator;
				_dRef = _darray.CreateArray(new IntPtr[1]);
				_tRef = _tarray.CreateArray(new IntPtr[1]);
			}

			public bool MoveNext()
			{
				if (_isFirst)
				{
					_isFirst = false;
					return true;
				}
				return NativeMethods.THSData_moveNext(_iterator.handle.DangerousGetHandle());
			}

			public void Reset()
			{
				_isFirst = true;
				NativeMethods.THSData_reset(_iterator.handle.DangerousGetHandle());
			}

			public void Dispose()
			{
				_darray.Dispose();
				_tarray.Dispose();
			}
		}

		protected HType handle;

		internal DataIterator(IntPtr handle)
		{
			this.handle = new HType(handle, ownsHandle: true);
		}

		~DataIterator()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (disposing)
			{
				NativeMethods.THSData_dispose(handle.DangerousGetHandle());
				handle.Dispose();
				handle.SetHandleAsInvalid();
			}
		}

		public long Size()
		{
			return NativeMethods.THSData_size(handle.DangerousGetHandle());
		}

		public IEnumerator<(torch.Tensor data, torch.Tensor target)> GetEnumerator()
		{
			DataIteratorEnumerator dataIteratorEnumerator = new DataIteratorEnumerator(this);
			dataIteratorEnumerator.Reset();
			return dataIteratorEnumerator;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public class Loader
	{
		public static DataIterator MNIST(string filename, long batchSize, bool isTrain = true)
		{
			return new DataIterator(NativeMethods.THSData_loaderMNIST(filename, batchSize, isTrain));
		}

		public static DataIterator CIFAR10(string path, long batchSize, bool isTrain = true)
		{
			return new DataIterator(NativeMethods.THSData_loaderCIFAR10(path, batchSize, isTrain));
		}
	}
}