using System;
using System.Buffers;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;
using Microsoft.ML.OnnxRuntime.Tensors;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.Common, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
[assembly: InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.Droid, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
[assembly: InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.iOS, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
[assembly: InternalsVisibleTo("Microsoft.ML.OnnxRuntime.Tests.NetCoreApp, PublicKey=002400000480000094000000060200000024000052534131000400000100010059013e94e4bc70136ca4c35f33acd6b62974536b698f9c7a21cee18d805c7ad860ad9eebfdc47a96ba2f8d03f4cf1c36b9d30787e276c7b9833b5bf2a6eba7e919e6b90083078a352262aed1d842e5f70a3085cbcf4c56ae851b161137920961c23fcc246598d61d258ccc615c927b2441359eea666a99ce1c3c07dca18fb0e1")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	internal sealed class IsByRefLikeAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Microsoft.ML.OnnxRuntime
{
	public interface IDisposableReadOnlyCollection<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IDisposable
	{
	}
	internal class DisposableList<T> : List<T>, IDisposableReadOnlyCollection<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IDisposable where T : IDisposable
	{
		private bool _disposed;

		public DisposableList()
		{
		}

		public DisposableList(int count)
			: base(count)
		{
		}

		public DisposableList(IEnumerable<T> collection)
			: base(collection)
		{
		}

		protected virtual void Dispose(bool disposing)
		{
			if (_disposed || !disposing)
			{
				return;
			}
			for (int num = base.Count - 1; num >= 0; num--)
			{
				T val = base[num];
				if (val != null)
				{
					val.Dispose();
				}
			}
			Clear();
			_disposed = true;
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class DisposableNamedOnnxValue : NamedOnnxValue, IDisposable
	{
		private IOrtValueOwner _ortValueHolder;

		private bool _disposed;

		public TensorElementType ElementType { get; }

		private DisposableNamedOnnxValue(string name, object value, TensorElementType elementType, IOrtValueOwner ortValueHolder)
			: base(name, value, OnnxValueType.ONNX_TYPE_TENSOR)
		{
			_ortValueHolder = ortValueHolder;
			ElementType = elementType;
		}

		private DisposableNamedOnnxValue(string name, object value, OnnxValueType onnxValueType, IOrtValueOwner ortValueHolder)
			: base(name, value, onnxValueType)
		{
			_ortValueHolder = ortValueHolder;
			ElementType = TensorElementType.DataTypeMax;
		}

		private DisposableNamedOnnxValue(string name, object value, MapHelper mapHelper, IOrtValueOwner ortValueHolder)
			: base(name, value, mapHelper)
		{
			_ortValueHolder = ortValueHolder;
			ElementType = TensorElementType.DataTypeMax;
		}

		internal override IntPtr InputToOrtValueHandle(NodeMetadata metadata, out IDisposable memoryHolder)
		{
			if (_ortValueHolder == null)
			{
				throw new InvalidOperationException("The instance of this class does not own an OrtValue");
			}
			memoryHolder = null;
			return _ortValueHolder.Value.Handle;
		}

		internal override IntPtr OutputToOrtValueHandle(NodeMetadata metadata, out IDisposable memoryOwner)
		{
			return InputToOrtValueHandle(metadata, out memoryOwner);
		}

		internal static DisposableNamedOnnxValue CreateFromOrtValue(string name, ref OrtValue ortValue)
		{
			return CreateFromOrtValue(name, ref ortValue, OrtAllocator.DefaultInstance);
		}

		internal static DisposableNamedOnnxValue CreateFromOrtValue(string name, ref OrtValue ortValue, OrtAllocator allocator)
		{
			OnnxValueType onnxType = ortValue.OnnxType;
			return onnxType switch
			{
				OnnxValueType.ONNX_TYPE_TENSOR => FromNativeTensor(name, ref ortValue), 
				OnnxValueType.ONNX_TYPE_SEQUENCE => FromNativeSequence(name, ref ortValue, allocator), 
				OnnxValueType.ONNX_TYPE_MAP => FromNativeMap(name, ref ortValue, allocator), 
				_ => throw new NotSupportedException($"OnnxValueType : {onnxType} is not supported"), 
			};
		}

		private static DisposableNamedOnnxValue FromNativeTensor(string name, ref OrtValue ortValue)
		{
			OrtTensorTypeAndShapeInfo tensorTypeAndShape = ortValue.GetTensorTypeAndShape();
			switch (tensorTypeAndShape.ElementDataType)
			{
			case TensorElementType.Float:
				return FromNativeTensor<float>(name, ref ortValue);
			case TensorElementType.Double:
				return FromNativeTensor<double>(name, ref ortValue);
			case TensorElementType.Int16:
				return FromNativeTensor<short>(name, ref ortValue);
			case TensorElementType.UInt16:
				return FromNativeTensor<ushort>(name, ref ortValue);
			case TensorElementType.Int32:
				return FromNativeTensor<int>(name, ref ortValue);
			case TensorElementType.UInt32:
				return FromNativeTensor<uint>(name, ref ortValue);
			case TensorElementType.Int64:
				return FromNativeTensor<long>(name, ref ortValue);
			case TensorElementType.UInt64:
				return FromNativeTensor<ulong>(name, ref ortValue);
			case TensorElementType.UInt8:
				return FromNativeTensor<byte>(name, ref ortValue);
			case TensorElementType.Int8:
				return FromNativeTensor<sbyte>(name, ref ortValue);
			case TensorElementType.String:
			{
				int[] shape = Array.ConvertAll(tensorTypeAndShape.Shape, Convert.ToInt32);
				return FromNativeStringTensor(name, shape, ref ortValue);
			}
			case TensorElementType.Bool:
				return FromNativeTensor<bool>(name, ref ortValue);
			case TensorElementType.Float16:
				return FromNativeTensor<Float16>(name, ref ortValue);
			case TensorElementType.BFloat16:
				return FromNativeTensor<BFloat16>(name, ref ortValue);
			default:
				throw new NotSupportedException($"Tensor of element type: {tensorTypeAndShape.ElementDataType} is not supported");
			}
		}

		private static DisposableNamedOnnxValue FromNativeStringTensor(string name, int[] shape, ref OrtValue ortValue)
		{
			DenseTensor<string> value = new DenseTensor<string>(ortValue.GetStringTensorAsArray(), shape);
			DisposableNamedOnnxValue result = new DisposableNamedOnnxValue(name, value, TensorElementType.String, ortValue);
			ortValue = null;
			return result;
		}

		private static DisposableNamedOnnxValue FromNativeTensor<T>(string name, ref OrtValue ortValue)
		{
			OrtValueTensor<T> ortValueTensor = new OrtValueTensor<T>(ref ortValue);
			try
			{
				DenseTensor<T> value = new DenseTensor<T>(ortValueTensor.Memory, ortValueTensor.Dimensions);
				return new DisposableNamedOnnxValue(name, value, ortValueTensor.ElementType, ortValueTensor);
			}
			catch (Exception)
			{
				ortValueTensor.Dispose();
				throw;
			}
		}

		private static DisposableNamedOnnxValue FromNativeSequence(string name, ref OrtValue ortValueSequence, OrtAllocator allocator)
		{
			int valueCount = ortValueSequence.GetValueCount();
			DisposableList<DisposableNamedOnnxValue> disposableList = new DisposableList<DisposableNamedOnnxValue>(valueCount);
			try
			{
				for (int i = 0; i < valueCount; i++)
				{
					OrtValue ortValue = ortValueSequence.GetValue(i, allocator);
					try
					{
						disposableList.Add(CreateFromOrtValue(string.Empty, ref ortValue, allocator));
					}
					finally
					{
						ortValue?.Dispose();
					}
				}
				NativeOrtValueCollectionOwner ortValueHolder = new NativeOrtValueCollectionOwner(ref ortValueSequence, disposableList);
				return new DisposableNamedOnnxValue(name, disposableList, OnnxValueType.ONNX_TYPE_SEQUENCE, ortValueHolder);
			}
			catch (Exception)
			{
				disposableList.Dispose();
				throw;
			}
		}

		private static DisposableNamedOnnxValue FromNativeMap(string name, ref OrtValue ortValueMap, OrtAllocator allocator)
		{
			DisposableNamedOnnxValue result = null;
			Span<OrtValue> disposables = new OrtValue[2];
			DisposableArray<OrtValue> disposableArray = new DisposableArray<OrtValue>(disposables);
			try
			{
				disposables[0] = ortValueMap.GetValue(0, allocator);
				disposables[1] = ortValueMap.GetValue(1, allocator);
				OrtTensorTypeAndShapeInfo tensorTypeAndShape = disposables[0].GetTensorTypeAndShape();
				OrtTensorTypeAndShapeInfo tensorTypeAndShape2 = disposables[1].GetTensorTypeAndShape();
				int[] keysShape = Array.ConvertAll(tensorTypeAndShape.Shape, Convert.ToInt32);
				int[] valsShape = Array.ConvertAll(tensorTypeAndShape2.Shape, Convert.ToInt32);
				result = tensorTypeAndShape.ElementDataType switch
				{
					TensorElementType.Int64 => tensorTypeAndShape2.ElementDataType switch
					{
						TensorElementType.Float => FromNativeMapElements<long, float>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						TensorElementType.Double => FromNativeMapElements<long, double>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						TensorElementType.Int64 => FromNativeMapElements<long, long>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						TensorElementType.String => FromNativeMapElements<long, string>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						_ => throw new NotSupportedException($"Map value type: {tensorTypeAndShape2.ElementDataType} is not supported"), 
					}, 
					TensorElementType.String => tensorTypeAndShape2.ElementDataType switch
					{
						TensorElementType.Float => FromNativeMapElements<string, float>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						TensorElementType.Double => FromNativeMapElements<string, double>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						TensorElementType.Int64 => FromNativeMapElements<string, long>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						TensorElementType.String => FromNativeMapElements<string, string>(name, ref ortValueMap, keysShape, ref disposables[0], valsShape, ref disposables[1]), 
						_ => throw new NotSupportedException($"Map value type: {tensorTypeAndShape2.ElementDataType} is not supported"), 
					}, 
					_ => throw new NotSupportedException($"Map key type: {tensorTypeAndShape.ElementDataType} is not supported"), 
				};
			}
			finally
			{
				disposableArray.Dispose();
			}
			return result;
		}

		private static DisposableNamedOnnxValue FromNativeMapElements<K, V>(string name, ref OrtValue ortValueMap, int[] keysShape, ref OrtValue ortValueTensorKeys, int[] valsShape, ref OrtValue ortValueTensorValues)
		{
			if (typeof(K) == typeof(string))
			{
				DenseTensor<string> denseTensorKeys = new DenseTensor<string>(ortValueTensorKeys.GetStringTensorAsArray(), keysShape);
				if (typeof(V) == typeof(string))
				{
					DenseTensor<string> denseTensorValues = new DenseTensor<string>(ortValueTensorValues.GetStringTensorAsArray(), valsShape);
					Dictionary<string, string> value = Enumerable.Range(0, (int)denseTensorKeys.Length).ToDictionary((int i) => denseTensorKeys[new int[1] { i }], (int i) => denseTensorValues[new int[1] { i }]);
					MapHelper mapHelper = new MapHelper(denseTensorKeys, denseTensorValues);
					DisposableNamedOnnxValue result = new DisposableNamedOnnxValue(name, value, mapHelper, ortValueMap);
					ortValueMap = null;
					return result;
				}
				OrtValueTensor<V> ortValueTensor = new OrtValueTensor<V>(ref ortValueTensorValues);
				try
				{
					DenseTensor<V> values = new DenseTensor<V>(ortValueTensor.Memory, ortValueTensor.Dimensions);
					return FromMapDenseTensors(name, ref ortValueMap, denseTensorKeys, values, ortValueTensor);
				}
				catch (Exception)
				{
					ortValueTensor.Dispose();
					throw;
				}
			}
			DisposableList<IDisposable> disposableList = new DisposableList<IDisposable>(2);
			try
			{
				OrtValueTensor<K> ortValueTensor2 = new OrtValueTensor<K>(ref ortValueTensorKeys);
				disposableList.Add(ortValueTensor2);
				DenseTensor<K> keys = new DenseTensor<K>(ortValueTensor2.Memory, ortValueTensor2.Dimensions);
				if (typeof(V) == typeof(string))
				{
					DenseTensor<string> values2 = new DenseTensor<string>(ortValueTensorValues.GetStringTensorAsArray(), valsShape);
					return FromMapDenseTensors(name, ref ortValueMap, keys, values2, disposableList);
				}
				OrtValueTensor<V> ortValueTensor3 = new OrtValueTensor<V>(ref ortValueTensorValues);
				disposableList.Add(ortValueTensor3);
				DenseTensor<V> values3 = new DenseTensor<V>(ortValueTensor3.Memory, ortValueTensor3.Dimensions);
				return FromMapDenseTensors(name, ref ortValueMap, keys, values3, disposableList);
			}
			catch (Exception)
			{
				disposableList.Dispose();
				throw;
			}
		}

		private static DisposableNamedOnnxValue FromMapDenseTensors<K, V>(string name, ref OrtValue ortValueMap, DenseTensor<K> keys, DenseTensor<V> values, IDisposable disposables)
		{
			Dictionary<K, V> value = Enumerable.Range(0, (int)keys.Length).ToDictionary((int i) => keys[new int[1] { i }], (int i) => values[new int[1] { i }]);
			MapHelper mapHelper = new MapHelper(keys, values);
			NativeOrtValueCollectionOwner ortValueHolder = new NativeOrtValueCollectionOwner(ref ortValueMap, disposables);
			return new DisposableNamedOnnxValue(name, value, mapHelper, ortValueHolder);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				if (disposing && _ortValueHolder != null)
				{
					_ortValueHolder.Dispose();
					_ortValueHolder = null;
				}
				_disposed = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
		}
	}
	internal enum ErrorCode
	{
		Ok,
		Fail,
		InvalidArgument,
		NoSuchFile,
		NoModel,
		EngineError,
		RuntimeException,
		InvalidProtobuf,
		ModelLoaded,
		NotImplemented,
		InvalidGraph,
		ShapeInferenceNotRegistered,
		RequirementNotRegistered
	}
	public class OnnxRuntimeException : Exception
	{
		private static Dictionary<ErrorCode, string> errorCodeToString = new Dictionary<ErrorCode, string>
		{
			{
				ErrorCode.Ok,
				"Ok"
			},
			{
				ErrorCode.Fail,
				"Fail"
			},
			{
				ErrorCode.InvalidArgument,
				"InvalidArgument"
			},
			{
				ErrorCode.NoSuchFile,
				"NoSuchFile"
			},
			{
				ErrorCode.NoModel,
				"NoModel"
			},
			{
				ErrorCode.EngineError,
				"EngineError"
			},
			{
				ErrorCode.RuntimeException,
				"RuntimeException"
			},
			{
				ErrorCode.InvalidProtobuf,
				"InvalidProtobuf"
			},
			{
				ErrorCode.ModelLoaded,
				"ModelLoaded"
			},
			{
				ErrorCode.NotImplemented,
				"NotImplemented"
			},
			{
				ErrorCode.InvalidGraph,
				"InvalidGraph"
			},
			{
				ErrorCode.ShapeInferenceNotRegistered,
				"ShapeInferenceNotRegistered"
			},
			{
				ErrorCode.RequirementNotRegistered,
				"RequirementNotRegistered"
			}
		};

		internal OnnxRuntimeException(ErrorCode errorCode, string message)
			: base("[ErrorCode:" + errorCodeToString[errorCode] + "] " + message)
		{
		}
	}
	public class FixedBufferOnnxValue : IDisposable
	{
		private bool _disposed = false;

		internal OrtValue Value { get; private set; }

		internal OnnxValueType OnnxValueType { get; private set; }

		internal TensorElementType ElementType { get; private set; }

		private FixedBufferOnnxValue(ref OrtValue ortValue, OnnxValueType onnxValueType, TensorElementType elementType)
		{
			Value = ortValue;
			ortValue = null;
			OnnxValueType = onnxValueType;
			ElementType = elementType;
		}

		public static FixedBufferOnnxValue CreateFromTensor<T>(Tensor<T> value)
		{
			TensorElementType elementType;
			OrtValue ortValue = OrtValue.CreateFromTensorObject(value, out elementType);
			return new FixedBufferOnnxValue(ref ortValue, OnnxValueType.ONNX_TYPE_TENSOR, elementType);
		}

		public static FixedBufferOnnxValue CreateFromMemory<T>(OrtMemoryInfo memoryInfo, Memory<T> memory, TensorElementType elementType, long[] shape, long bytesSize) where T : unmanaged
		{
			if (elementType == TensorElementType.String)
			{
				throw new ArgumentException("String data type is not supported");
			}
			OrtValue ortValue = OrtValue.CreateTensorValueFromMemory(memoryInfo, memory, shape);
			try
			{
				return new FixedBufferOnnxValue(ref ortValue, OnnxValueType.ONNX_TYPE_TENSOR, elementType);
			}
			catch (Exception)
			{
				ortValue?.Dispose();
				throw;
			}
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				if (disposing)
				{
					Value.Dispose();
				}
				_disposed = true;
			}
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}
	}
	public class InferenceSession : IDisposable
	{
		private delegate string NameExtractor<in TInput>(TInput input);

		private delegate IntPtr OrtValueHandleExtractor(NamedOnnxValue value, NodeMetadata metadata, out IDisposable memOwner);

		private delegate NodeMetadata MetadataLookup(string nodeName);

		[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
		private delegate void OrtCallbackDelegate(IntPtr userData, IntPtr[] outputs, uint numOutputs, IntPtr status);

		private delegate void UserCallbackDelegate(IReadOnlyCollection<OrtValue> outputs, IntPtr status);

		private class CallbackHost
		{
			public IReadOnlyCollection<string> inputNames { get; }

			public IReadOnlyCollection<OrtValue> inputValues { get; }

			public IReadOnlyCollection<string> outputNames { get; }

			public IReadOnlyCollection<OrtValue> outputValues { get; }

			public UserCallbackDelegate callback { get; }

			public IntPtr[] rawInputNames { get; }

			public IntPtr[] rawInputValues { get; }

			public IntPtr[] rawOutputNames { get; }

			public IntPtr[] rawOutputValues { get; }

			public CallbackHost(InferenceSession session, IReadOnlyCollection<string> cbInputNames, IReadOnlyCollection<OrtValue> cbinputValues, IReadOnlyCollection<string> cbOutputNames, IReadOnlyCollection<OrtValue> cbOutputValues, UserCallbackDelegate userCallback)
			{
				inputNames = cbInputNames;
				inputValues = cbinputValues;
				outputNames = cbOutputNames;
				outputValues = cbOutputValues;
				callback = userCallback;
				rawInputNames = LookupUtf8Names(inputNames, (string n) => n, session.LookupInputMetadata);
				rawInputValues = inputValues.Select((OrtValue v) => v.Handle).ToArray();
				rawOutputNames = LookupUtf8Names(outputNames, (string n) => n, session.LookupOutputMetadata);
				rawOutputValues = outputValues.Select((OrtValue v) => v.Handle).ToArray();
			}
		}

		private IntPtr _nativeHandle;

		private Dictionary<string, NodeMetadata> _inputMetadata;

		private List<string> _inputNames;

		private Dictionary<string, NodeMetadata> _outputMetadata;

		private List<string> _outputNames;

		private Dictionary<string, NodeMetadata> _overridableInitializerMetadata;

		private List<IntPtr> _namesMemoryPtrs;

		private SessionOptions _builtInSessionOptions = null;

		private RunOptions _builtInRunOptions = null;

		private ModelMetadata _modelMetadata = null;

		private bool _disposed = false;

		private ulong _profilingStartTimeNs = 0uL;

		private static OrtCallbackDelegate ortCallback = OrtCallback;

		public IReadOnlyDictionary<string, NodeMetadata> InputMetadata => _inputMetadata;

		public IReadOnlyList<string> InputNames => _inputNames;

		public IReadOnlyDictionary<string, NodeMetadata> OutputMetadata => _outputMetadata;

		public IReadOnlyList<string> OutputNames => _outputNames;

		public IReadOnlyDictionary<string, NodeMetadata> OverridableInitializerMetadata => _overridableInitializerMetadata;

		public ModelMetadata ModelMetadata
		{
			get
			{
				if (_modelMetadata != null)
				{
					return _modelMetadata;
				}
				_modelMetadata = new ModelMetadata(this);
				return _modelMetadata;
			}
		}

		public ulong ProfilingStartTimeNs => _profilingStartTimeNs;

		internal IntPtr Handle => _nativeHandle;

		public InferenceSession(string modelPath)
		{
			_builtInSessionOptions = new SessionOptions();
			Init(modelPath, _builtInSessionOptions);
		}

		public InferenceSession(string modelPath, PrePackedWeightsContainer prepackedWeightsContainer)
		{
			_builtInSessionOptions = new SessionOptions();
			Init(modelPath, _builtInSessionOptions, prepackedWeightsContainer);
		}

		public InferenceSession(string modelPath, SessionOptions options)
		{
			Init(modelPath, options);
		}

		public InferenceSession(string modelPath, SessionOptions options, PrePackedWeightsContainer prepackedWeightsContainer)
		{
			Init(modelPath, options, prepackedWeightsContainer);
		}

		public InferenceSession(byte[] model)
		{
			_builtInSessionOptions = new SessionOptions();
			Init(model, _builtInSessionOptions);
		}

		public InferenceSession(byte[] model, PrePackedWeightsContainer prepackedWeightsContainer)
		{
			_builtInSessionOptions = new SessionOptions();
			Init(model, _builtInSessionOptions, prepackedWeightsContainer);
		}

		public InferenceSession(byte[] model, SessionOptions options)
		{
			Init(model, options);
		}

		public InferenceSession(byte[] model, SessionOptions options, PrePackedWeightsContainer prepackedWeightsContainer)
		{
			Init(model, options, prepackedWeightsContainer);
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> Run(IReadOnlyCollection<NamedOnnxValue> inputs)
		{
			return Run(inputs, _outputNames);
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> Run(IReadOnlyCollection<NamedOnnxValue> inputs, IReadOnlyCollection<string> outputNames)
		{
			return Run(inputs, outputNames, _builtInRunOptions);
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> Run(IReadOnlyCollection<NamedOnnxValue> inputs, IReadOnlyCollection<string> outputNames, RunOptions options)
		{
			IntPtr[] inputNames = LookupUtf8Names(inputs, (NamedOnnxValue v) => v.Name, LookupInputMetadata);
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			DisposableArray<IDisposable> disposer;
			IntPtr[] ortValuesHandles = GetOrtValuesHandles(inputs, LookupInputMetadata, ExtractOrtValueHandleForInput, out disposer);
			try
			{
				using DisposableOrtValueHandleArray disposableOrtValueHandleArray = RunImpl(options, inputNames, ortValuesHandles, outputNames2);
				return CreateDisposableResult(disposableOrtValueHandleArray.Span, outputNames);
			}
			finally
			{
				disposer.Dispose();
			}
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues)
		{
			return Run(inputNames, inputValues, _outputNames, _builtInRunOptions);
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues, IReadOnlyCollection<string> outputNames)
		{
			return Run(inputNames, inputValues, outputNames, _builtInRunOptions);
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues, IReadOnlyCollection<string> outputNames, RunOptions options)
		{
			if (inputNames.Count != inputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "inputNames", inputNames.Count, "inputValues", inputValues.Count));
			}
			IntPtr[] inputNames2 = LookupUtf8Names(inputNames, (string n) => n, LookupInputMetadata);
			IntPtr[] ortValuesHandles = GetOrtValuesHandles(inputValues, input: true);
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			using DisposableOrtValueHandleArray disposableOrtValueHandleArray = RunImpl(options, inputNames2, ortValuesHandles, outputNames2);
			return CreateDisposableResult(disposableOrtValueHandleArray.Span, outputNames);
		}

		public void Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<FixedBufferOnnxValue> outputValues)
		{
			Run(inputNames, inputValues, outputNames, outputValues, _builtInRunOptions);
		}

		public void Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<FixedBufferOnnxValue> outputValues, RunOptions options)
		{
			if (inputNames.Count != inputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "inputNames", inputNames.Count, "inputValues", inputValues.Count));
			}
			if (outputNames.Count != outputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "outputNames", outputNames.Count, "outputValues", outputValues.Count));
			}
			IntPtr[] inputNames2 = LookupUtf8Names(inputNames, (string n) => n, LookupInputMetadata);
			IntPtr[] ortValuesHandles = GetOrtValuesHandles(inputValues, input: true);
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			IntPtr[] ortValuesHandles2 = GetOrtValuesHandles(outputValues, input: false);
			NativeApiStatus.VerifySuccess(NativeMethods.OrtRun(_nativeHandle, options.Handle, inputNames2, ortValuesHandles, (UIntPtr)(ulong)inputNames.Count, outputNames2, (UIntPtr)(ulong)outputNames.Count, ortValuesHandles2));
		}

		public void Run(IReadOnlyCollection<NamedOnnxValue> inputs, IReadOnlyCollection<NamedOnnxValue> outputs)
		{
			Run(inputs, outputs, _builtInRunOptions);
		}

		public void Run(IReadOnlyCollection<NamedOnnxValue> inputs, IReadOnlyCollection<NamedOnnxValue> outputs, RunOptions options)
		{
			IntPtr[] inputNames = LookupUtf8Names(inputs, (NamedOnnxValue i) => i.Name, LookupInputMetadata);
			IntPtr[] outputNames = LookupUtf8Names(outputs, (NamedOnnxValue o) => o.Name, LookupOutputMetadata);
			DisposableArray<IDisposable> disposer;
			IntPtr[] ortValuesHandles = GetOrtValuesHandles(inputs, LookupInputMetadata, ExtractOrtValueHandleForInput, out disposer);
			try
			{
				DisposableArray<IDisposable> disposer2;
				IntPtr[] ortValuesHandles2 = GetOrtValuesHandles(outputs, LookupOutputMetadata, ExtractOrtValueHandleForOutput, out disposer2);
				try
				{
					NativeApiStatus.VerifySuccess(NativeMethods.OrtRun(_nativeHandle, options.Handle, inputNames, ortValuesHandles, (UIntPtr)(ulong)inputs.Count, outputNames, (UIntPtr)(ulong)outputs.Count, ortValuesHandles2));
				}
				finally
				{
					disposer2.Dispose();
				}
			}
			finally
			{
				disposer.Dispose();
			}
		}

		public void Run(IReadOnlyCollection<NamedOnnxValue> inputs, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<FixedBufferOnnxValue> outputValues)
		{
			Run(inputs, outputNames, outputValues, _builtInRunOptions);
		}

		public void Run(IReadOnlyCollection<NamedOnnxValue> inputs, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<FixedBufferOnnxValue> outputValues, RunOptions options)
		{
			if (outputNames.Count != outputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "outputNames", outputNames.Count, "outputValues", outputValues.Count));
			}
			IntPtr[] inputNames = LookupUtf8Names(inputs, (NamedOnnxValue i) => i.Name, LookupInputMetadata);
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			IntPtr[] ortValuesHandles = GetOrtValuesHandles(outputValues, input: false);
			DisposableArray<IDisposable> disposer;
			IntPtr[] ortValuesHandles2 = GetOrtValuesHandles(inputs, LookupInputMetadata, ExtractOrtValueHandleForInput, out disposer);
			try
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtRun(_nativeHandle, options.Handle, inputNames, ortValuesHandles2, (UIntPtr)(ulong)inputs.Count, outputNames2, (UIntPtr)(ulong)outputNames.Count, ortValuesHandles));
			}
			finally
			{
				disposer.Dispose();
			}
		}

		public void Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues, IReadOnlyCollection<NamedOnnxValue> outputs)
		{
			Run(inputNames, inputValues, outputs, _builtInRunOptions);
		}

		public void Run(IReadOnlyCollection<string> inputNames, IReadOnlyCollection<FixedBufferOnnxValue> inputValues, IReadOnlyCollection<NamedOnnxValue> outputs, RunOptions options)
		{
			if (inputNames.Count != inputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "inputNames", inputNames.Count, "inputValues", inputValues.Count));
			}
			IntPtr[] inputNames2 = LookupUtf8Names(inputNames, (string n) => n, LookupInputMetadata);
			IntPtr[] ortValuesHandles = GetOrtValuesHandles(inputValues, input: true);
			IntPtr[] outputNames = LookupUtf8Names(outputs, (NamedOnnxValue o) => o.Name, LookupOutputMetadata);
			DisposableArray<IDisposable> disposer;
			IntPtr[] ortValuesHandles2 = GetOrtValuesHandles(outputs, LookupOutputMetadata, ExtractOrtValueHandleForOutput, out disposer);
			try
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtRun(_nativeHandle, options.Handle, inputNames2, ortValuesHandles, (UIntPtr)(ulong)inputNames.Count, outputNames, (UIntPtr)(ulong)outputs.Count, ortValuesHandles2));
			}
			finally
			{
				disposer.Dispose();
			}
		}

		public IDisposableReadOnlyCollection<OrtValue> Run(RunOptions runOptions, IReadOnlyCollection<string> inputNames, IReadOnlyCollection<OrtValue> inputValues, IReadOnlyCollection<string> outputNames)
		{
			if (inputNames.Count != inputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "inputNames", inputNames.Count, "inputValues", inputValues.Count));
			}
			IntPtr[] inputNames2 = LookupUtf8Names(inputNames, (string n) => n, LookupInputMetadata);
			IntPtr[] inputValues2 = inputValues.Select((OrtValue v) => v.Handle).ToArray();
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			using DisposableOrtValueHandleArray disposableHandles = RunImpl(runOptions, inputNames2, inputValues2, outputNames2);
			return CreateDisposableResult(disposableHandles);
		}

		public IDisposableReadOnlyCollection<OrtValue> Run(RunOptions runOptions, IReadOnlyDictionary<string, OrtValue> inputs, IReadOnlyCollection<string> outputNames)
		{
			IntPtr[] array = new IntPtr[inputs.Count];
			IntPtr[] array2 = new IntPtr[inputs.Count];
			int num = 0;
			foreach (KeyValuePair<string, OrtValue> input in inputs)
			{
				array[num] = LookupInputMetadata(input.Key).ZeroTerminatedName;
				array2[num] = input.Value.Handle;
				num++;
			}
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			using DisposableOrtValueHandleArray disposableHandles = RunImpl(runOptions, array, array2, outputNames2);
			return CreateDisposableResult(disposableHandles);
		}

		private static IDisposableReadOnlyCollection<OrtValue> CreateDisposableResult(DisposableOrtValueHandleArray disposableHandles)
		{
			DisposableList<OrtValue> disposableList = new DisposableList<OrtValue>(disposableHandles.Span.Length);
			try
			{
				for (int i = 0; i < disposableHandles.Span.Length; i++)
				{
					disposableList.Add(new OrtValue(disposableHandles.Span[i]));
					disposableHandles.Span[i] = IntPtr.Zero;
				}
				return disposableList;
			}
			catch (Exception)
			{
				disposableList.Dispose();
				throw;
			}
		}

		public void Run(RunOptions runOptions, IReadOnlyCollection<string> inputNames, IReadOnlyCollection<OrtValue> inputValues, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<OrtValue> outputValues)
		{
			if (inputNames.Count != inputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "inputNames", inputNames.Count, "inputValues", inputValues.Count));
			}
			if (outputNames.Count != outputValues.Count)
			{
				throw new ArgumentException(string.Format("Length of {0} ({1}) must match that of {2} ({3}).", "outputNames", outputNames.Count, "outputValues", outputValues.Count));
			}
			if (runOptions == null)
			{
				runOptions = _builtInRunOptions;
			}
			IntPtr[] inputNames2 = LookupUtf8Names(inputNames, (string n) => n, LookupInputMetadata);
			IntPtr[] inputValues2 = inputValues.Select((OrtValue v) => v.Handle).ToArray();
			IntPtr[] outputNames2 = LookupUtf8Names(outputNames, (string n) => n, LookupOutputMetadata);
			IntPtr[] outputValues2 = outputValues.Select((OrtValue v) => v.Handle).ToArray();
			NativeApiStatus.VerifySuccess(NativeMethods.OrtRun(_nativeHandle, runOptions.Handle, inputNames2, inputValues2, (UIntPtr)(ulong)inputNames.Count, outputNames2, (UIntPtr)(ulong)outputNames.Count, outputValues2));
		}

		public OrtIoBinding CreateIoBinding()
		{
			return new OrtIoBinding(this);
		}

		public void RunWithBinding(RunOptions runOptions, OrtIoBinding ioBinding)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtRunWithBinding(Handle, runOptions.Handle, ioBinding.Handle));
		}

		public IDisposableReadOnlyCollection<OrtValue> RunWithBoundResults(RunOptions runOptions, OrtIoBinding ioBinding)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtRunWithBinding(Handle, runOptions.Handle, ioBinding.Handle));
			return ioBinding.GetOutputValues();
		}

		public IDisposableReadOnlyCollection<DisposableNamedOnnxValue> RunWithBindingAndNames(RunOptions runOptions, OrtIoBinding ioBinding, string[] names = null)
		{
			string[] array = names;
			if (array == null || names.Length == 0)
			{
				array = ioBinding.GetOutputNames();
			}
			NativeApiStatus.VerifySuccess(NativeMethods.OrtRunWithBinding(Handle, runOptions.Handle, ioBinding.Handle));
			OrtValue[] outputOrtValues = ioBinding.GetOutputOrtValues();
			DisposableArray<OrtValue> disposableArray = new DisposableArray<OrtValue>(outputOrtValues);
			try
			{
				DisposableList<DisposableNamedOnnxValue> disposableList = new DisposableList<DisposableNamedOnnxValue>(outputOrtValues.Length);
				try
				{
					for (int i = 0; i < array.Length; i++)
					{
						disposableList.Add(DisposableNamedOnnxValue.CreateFromOrtValue(array[i], ref outputOrtValues[i]));
					}
					return disposableList;
				}
				catch (Exception)
				{
					disposableList.Dispose();
					throw;
				}
			}
			finally
			{
				disposableArray.Dispose();
			}
		}

		public string EndProfiling()
		{
			OrtAllocator defaultInstance = OrtAllocator.DefaultInstance;
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionEndProfiling(_nativeHandle, defaultInstance.Pointer, out var profile_file));
			return NativeOnnxValueHelper.StringFromNativeUtf8(profile_file, defaultInstance);
		}

		private NodeMetadata LookupInputMetadata(string nodeName)
		{
			if (!_inputMetadata.TryGetValue(nodeName, out var value) && !_overridableInitializerMetadata.TryGetValue(nodeName, out value))
			{
				throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "Input name: '" + nodeName + "' is not in the metadata");
			}
			return value;
		}

		private NodeMetadata LookupOutputMetadata(string nodeName)
		{
			if (!_outputMetadata.TryGetValue(nodeName, out var value))
			{
				throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "Output name: '" + nodeName + "' is not in the metadata");
			}
			return value;
		}

		private static IntPtr ExtractOrtValueHandleForInput(NamedOnnxValue input, NodeMetadata metadata, out IDisposable memOwner)
		{
			return input.InputToOrtValueHandle(metadata, out memOwner);
		}

		private static IntPtr ExtractOrtValueHandleForOutput(NamedOnnxValue output, NodeMetadata metadata, out IDisposable memOwner)
		{
			return output.OutputToOrtValueHandle(metadata, out memOwner);
		}

		private static IntPtr[] LookupUtf8Names<T>(IReadOnlyCollection<T> values, NameExtractor<T> nameExtractor, MetadataLookup metaLookup)
		{
			IntPtr[] array = new IntPtr[values.Count];
			for (int i = 0; i < values.Count; i++)
			{
				string nodeName = nameExtractor(values.ElementAt(i));
				NodeMetadata nodeMetadata = metaLookup(nodeName);
				array[i] = nodeMetadata.ZeroTerminatedName;
			}
			return array;
		}

		private static IntPtr[] GetOrtValuesHandles(IReadOnlyCollection<NamedOnnxValue> values, MetadataLookup metaLookup, OrtValueHandleExtractor ortValueExtractor, out DisposableArray<IDisposable> disposer)
		{
			IDisposable[] array = new IDisposable[values.Count];
			DisposableArray<IDisposable> disposableArray = new DisposableArray<IDisposable>(array);
			try
			{
				IntPtr[] array2 = new IntPtr[values.Count];
				for (int i = 0; i < values.Count; i++)
				{
					NamedOnnxValue namedOnnxValue = values.ElementAt(i);
					NodeMetadata metadata = metaLookup(namedOnnxValue.Name);
					array2[i] = ortValueExtractor(namedOnnxValue, metadata, out var memOwner);
					if (memOwner != null)
					{
						array[i] = memOwner;
					}
				}
				disposer = disposableArray;
				return array2;
			}
			catch (Exception)
			{
				disposableArray.Dispose();
				throw;
			}
		}

		private static IntPtr[] GetOrtValuesHandles(IReadOnlyCollection<FixedBufferOnnxValue> values, bool input)
		{
			IntPtr[] array = new IntPtr[values.Count];
			for (int i = 0; i < values.Count; i++)
			{
				FixedBufferOnnxValue fixedBufferOnnxValue = values.ElementAt(i);
				if (!input && fixedBufferOnnxValue.ElementType == TensorElementType.String)
				{
					throw new NotSupportedException("Using string type FixedBufferOnnxValue in outputs is not supported.");
				}
				array[i] = fixedBufferOnnxValue.Value.Handle;
			}
			return array;
		}

		private DisposableOrtValueHandleArray RunImpl(RunOptions options, IntPtr[] inputNames, IntPtr[] inputValues, IntPtr[] outputNames)
		{
			IntPtr[] array = new IntPtr[outputNames.Length];
			NativeApiStatus.VerifySuccess(NativeMethods.OrtRun(_nativeHandle, options.Handle, inputNames, inputValues, (UIntPtr)(ulong)inputNames.Length, outputNames, (UIntPtr)(ulong)outputNames.Length, array));
			return new DisposableOrtValueHandleArray(array);
		}

		private static IDisposableReadOnlyCollection<DisposableNamedOnnxValue> CreateDisposableResult(Span<IntPtr> valueHandles, IReadOnlyCollection<string> outputNames)
		{
			DisposableList<DisposableNamedOnnxValue> disposableList = new DisposableList<DisposableNamedOnnxValue>(valueHandles.Length);
			try
			{
				for (int i = 0; i < valueHandles.Length; i++)
				{
					OrtValue ortValue = new OrtValue(valueHandles[i]);
					disposableList.Add(DisposableNamedOnnxValue.CreateFromOrtValue(outputNames.ElementAt(i), ref ortValue));
					valueHandles[i] = IntPtr.Zero;
				}
			}
			catch (OnnxRuntimeException)
			{
				disposableList.Dispose();
				throw;
			}
			return disposableList;
		}

		private static void OrtCallback(IntPtr userData, IntPtr[] ouputs, uint numOutputs, IntPtr status)
		{
			GCHandle gCHandle = GCHandle.FromIntPtr(userData);
			CallbackHost callbackHost = (CallbackHost)gCHandle.Target;
			try
			{
				callbackHost.callback(callbackHost.outputValues, status);
			}
			finally
			{
				gCHandle.Free();
			}
		}

		private unsafe void RunAsyncInternal(RunOptions options, IReadOnlyCollection<string> inputNames, IReadOnlyCollection<OrtValue> inputValues, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<OrtValue> outputValues, UserCallbackDelegate callback)
		{
			CallbackHost callbackHost = new CallbackHost(this, inputNames, inputValues, outputNames, outputValues, callback);
			GCHandle value = GCHandle.Alloc(callbackHost, GCHandleType.Normal);
			try
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtRunAsync(_nativeHandle, options?.Handle ?? ((IntPtr)(void*)null), callbackHost.rawInputNames, callbackHost.rawInputValues, (UIntPtr)(ulong)callbackHost.rawInputNames.Length, callbackHost.rawOutputNames, (UIntPtr)(ulong)callbackHost.rawOutputNames.Length, callbackHost.rawOutputValues, Marshal.GetFunctionPointerForDelegate(ortCallback), GCHandle.ToIntPtr(value)));
			}
			catch (OnnxRuntimeException)
			{
				value.Free();
				throw;
			}
		}

		public async Task<IReadOnlyCollection<OrtValue>> RunAsync(RunOptions options, IReadOnlyCollection<string> inputNames, IReadOnlyCollection<OrtValue> inputValues, IReadOnlyCollection<string> outputNames, IReadOnlyCollection<OrtValue> outputValues)
		{
			TaskCompletionSource<IReadOnlyCollection<OrtValue>> promise = new TaskCompletionSource<IReadOnlyCollection<OrtValue>>();
			RunAsyncInternal(options, inputNames, inputValues, outputNames, outputValues, delegate(IReadOnlyCollection<OrtValue> outputs, IntPtr status)
			{
				try
				{
					NativeApiStatus.VerifySuccess(status);
					promise.SetResult(outputs);
				}
				catch (Exception exception)
				{
					promise.SetException(exception);
				}
			});
			return await promise.Task;
		}

		private void Init(string modelPath, SessionOptions options, PrePackedWeightsContainer prepackedWeightsContainer = null)
		{
			IntPtr handle = OrtEnv.Instance().Handle;
			IntPtr session;
			if (prepackedWeightsContainer == null)
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtCreateSession(handle, NativeOnnxValueHelper.GetPlatformSerializedString(modelPath), options.Handle, out session));
			}
			else
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtCreateSessionWithPrepackedWeightsContainer(handle, NativeOnnxValueHelper.GetPlatformSerializedString(modelPath), options.Handle, prepackedWeightsContainer.Pointer, out session));
			}
			InitWithSessionHandle(session);
		}

		private void Init(byte[] modelData, SessionOptions options, PrePackedWeightsContainer prepackedWeightsContainer = null)
		{
			IntPtr handle = OrtEnv.Instance().Handle;
			IntPtr session;
			if (prepackedWeightsContainer == null)
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtCreateSessionFromArray(handle, modelData, (UIntPtr)(ulong)modelData.Length, options.Handle, out session));
			}
			else
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtCreateSessionFromArrayWithPrepackedWeightsContainer(handle, modelData, (UIntPtr)(ulong)modelData.Length, options.Handle, prepackedWeightsContainer.Pointer, out session));
			}
			InitWithSessionHandle(session);
		}

		private void InitWithSessionHandle(IntPtr session)
		{
			_nativeHandle = session;
			try
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetInputCount(_nativeHandle, out var count));
				NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetOutputCount(_nativeHandle, out var count2));
				NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetOverridableInitializerCount(_nativeHandle, out var count3));
				int capacity = (int)((uint)count + (uint)count2 + (uint)count3);
				_namesMemoryPtrs = new List<IntPtr>(capacity);
				_inputMetadata = new Dictionary<string, NodeMetadata>((int)(uint)count);
				_inputNames = new List<string>((int)(uint)count);
				for (ulong num = 0uL; num < (ulong)count; num++)
				{
					NodeMetadata inputMetadata = GetInputMetadata(num);
					IntPtr utf;
					string inputName = GetInputName(num, out utf);
					_namesMemoryPtrs.Add(utf);
					inputMetadata.ZeroTerminatedName = utf;
					_inputNames.Add(inputName);
					_inputMetadata[inputName] = inputMetadata;
				}
				_outputMetadata = new Dictionary<string, NodeMetadata>((int)(uint)count2);
				_outputNames = new List<string>((int)(uint)count2);
				for (ulong num2 = 0uL; num2 < (ulong)count2; num2++)
				{
					NodeMetadata outputMetadata = GetOutputMetadata(num2);
					IntPtr utf2;
					string outputName = GetOutputName(num2, out utf2);
					_namesMemoryPtrs.Add(utf2);
					outputMetadata.ZeroTerminatedName = utf2;
					_outputNames.Add(outputName);
					_outputMetadata[outputName] = outputMetadata;
				}
				_overridableInitializerMetadata = new Dictionary<string, NodeMetadata>((int)(uint)count3);
				for (ulong num3 = 0uL; num3 < (ulong)count3; num3++)
				{
					NodeMetadata overridableInitializerMetadata = GetOverridableInitializerMetadata(num3);
					IntPtr utf3;
					string overridableInitializerName = GetOverridableInitializerName(num3, out utf3);
					_namesMemoryPtrs.Add(utf3);
					overridableInitializerMetadata.ZeroTerminatedName = utf3;
					_overridableInitializerMetadata[overridableInitializerName] = overridableInitializerMetadata;
				}
				NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetProfilingStartTimeNs(_nativeHandle, out var startTime));
				_profilingStartTimeNs = (ulong)startTime;
			}
			catch (Exception)
			{
				DisposeImpl(disposing: true);
				throw;
			}
			_builtInRunOptions = new RunOptions();
		}

		private string GetOutputName(ulong index, out IntPtr utf8)
		{
			OrtAllocator defaultInstance = OrtAllocator.DefaultInstance;
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetOutputName(_nativeHandle, (UIntPtr)index, defaultInstance.Pointer, out var name));
			NativeOnnxValueHelper.StringAndUtf8FromNative(defaultInstance, name, out var str, out utf8);
			return str;
		}

		private string GetInputName(ulong index, out IntPtr utf8)
		{
			OrtAllocator defaultInstance = OrtAllocator.DefaultInstance;
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetInputName(_nativeHandle, (UIntPtr)index, defaultInstance.Pointer, out var name));
			NativeOnnxValueHelper.StringAndUtf8FromNative(defaultInstance, name, out var str, out utf8);
			return str;
		}

		private string GetOverridableInitializerName(ulong index, out IntPtr utf8)
		{
			OrtAllocator defaultInstance = OrtAllocator.DefaultInstance;
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetOverridableInitializerName(_nativeHandle, (UIntPtr)index, defaultInstance.Pointer, out var name));
			NativeOnnxValueHelper.StringAndUtf8FromNative(defaultInstance, name, out var str, out utf8);
			return str;
		}

		private NodeMetadata GetInputMetadata(ulong index)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetInputTypeInfo(_nativeHandle, (UIntPtr)index, out var typeInfo));
			try
			{
				return GetMetadataFromTypeInfo(typeInfo);
			}
			finally
			{
				NativeMethods.OrtReleaseTypeInfo(typeInfo);
			}
		}

		private NodeMetadata GetOutputMetadata(ulong index)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetOutputTypeInfo(_nativeHandle, (UIntPtr)index, out var typeInfo));
			try
			{
				return GetMetadataFromTypeInfo(typeInfo);
			}
			finally
			{
				NativeMethods.OrtReleaseTypeInfo(typeInfo);
			}
		}

		private NodeMetadata GetOverridableInitializerMetadata(ulong index)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetOverridableInitializerTypeInfo(_nativeHandle, (UIntPtr)index, out var typeInfo));
			try
			{
				return GetMetadataFromTypeInfo(typeInfo);
			}
			finally
			{
				NativeMethods.OrtReleaseTypeInfo(typeInfo);
			}
		}

		internal static NodeMetadata GetMetadataFromTypeInfo(IntPtr typeInfo)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetOnnxTypeFromTypeInfo(typeInfo, out var onnxtype));
			OnnxValueType onnxValueType = (OnnxValueType)(int)onnxtype;
			switch (onnxValueType)
			{
			case OnnxValueType.ONNX_TYPE_TENSOR:
			case OnnxValueType.ONNX_TYPE_SPARSETENSOR:
				return GetTensorNodeMetadata(onnxValueType, typeInfo);
			case OnnxValueType.ONNX_TYPE_SEQUENCE:
				return GetSequenceMetadataFromTypeInfo(typeInfo);
			case OnnxValueType.ONNX_TYPE_MAP:
				return GetMapMetadataFromTypeInfo(typeInfo);
			case OnnxValueType.ONNX_TYPE_OPTIONAL:
				return GetOptionalMetadataFromTypeInfo(typeInfo);
			default:
				throw new OnnxRuntimeException(ErrorCode.NotImplemented, $"Value type: '{onnxValueType}' not supported in this code");
			}
		}

		internal static NodeMetadata GetSequenceMetadataFromTypeInfo(IntPtr typeInfo)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtCastTypeInfoToSequenceTypeInfo(typeInfo, out var sequenceTypeInfo));
			if (sequenceTypeInfo == IntPtr.Zero)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "TypeInfo cast to SequenceTypeInfo failed. The object does not represent a sequence");
			}
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetSequenceElementType(sequenceTypeInfo, out var elementTypeInfo));
			try
			{
				NodeMetadata metadataFromTypeInfo = GetMetadataFromTypeInfo(elementTypeInfo);
				SequenceMetadata sequenceMetadata = new SequenceMetadata(metadataFromTypeInfo);
				return new NodeMetadata(sequenceMetadata);
			}
			finally
			{
				NativeMethods.OrtReleaseTypeInfo(elementTypeInfo);
			}
		}

		internal static NodeMetadata GetMapMetadataFromTypeInfo(IntPtr typeInfo)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtCastTypeInfoToMapTypeInfo(typeInfo, out var mapTypeInfo));
			if (mapTypeInfo == IntPtr.Zero)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "TypeInfo cast to MapTypeInfo failed. The object does not represent a map");
			}
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetMapKeyType(mapTypeInfo, out var tensorElementType));
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetMapValueType(mapTypeInfo, out var type_info));
			try
			{
				NodeMetadata metadataFromTypeInfo = GetMetadataFromTypeInfo(type_info);
				MapMetadata mapMetadata = new MapMetadata((TensorElementType)(int)tensorElementType, metadataFromTypeInfo);
				return new NodeMetadata(mapMetadata);
			}
			finally
			{
				NativeMethods.OrtReleaseTypeInfo(type_info);
			}
		}

		internal static NodeMetadata GetOptionalMetadataFromTypeInfo(IntPtr typeInfo)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtCastTypeInfoToOptionalTypeInfo(typeInfo, out var optionalTypeInfo));
			if (optionalTypeInfo == IntPtr.Zero)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "TypeInfo cast to OptionalTypeInfo failed. The object does not represent a optional value");
			}
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetOptionalContainedTypeInfo(optionalTypeInfo, out var containedTypeInfo));
			try
			{
				NodeMetadata metadataFromTypeInfo = GetMetadataFromTypeInfo(containedTypeInfo);
				OptionalMetadata optMetadata = new OptionalMetadata(metadataFromTypeInfo);
				return new NodeMetadata(optMetadata);
			}
			finally
			{
				NativeMethods.OrtReleaseTypeInfo(containedTypeInfo);
			}
		}

		internal static NodeMetadata GetTensorNodeMetadata(OnnxValueType valueType, IntPtr typeInfo)
		{
			NativeApiStatus.VerifySuccess(NativeMethods.OrtCastTypeInfoToTensorInfo(typeInfo, out var typeAndShapeInfo));
			if (typeAndShapeInfo == IntPtr.Zero)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "TypeInfo cast to TensorTypeInfo failed. The object does not represent a tensor");
			}
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetTensorElementType(typeAndShapeInfo, out var output));
			TensorElementType elementType = (TensorElementType)(int)output;
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetDimensionsCount(typeAndShapeInfo, out var output2));
			long[] array = new long[(uint)output2];
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetDimensions(typeAndShapeInfo, array, output2));
			int[] array2 = new int[(uint)output2];
			for (int i = 0; (long)i < (long)(ulong)output2; i++)
			{
				array2[i] = (int)array[i];
			}
			IntPtr[] array3 = new IntPtr[(uint)output2];
			NativeApiStatus.VerifySuccess(NativeMethods.OrtGetSymbolicDimensions(typeAndShapeInfo, array3, output2));
			string[] array4 = new string[(uint)output2];
			for (int j = 0; j < (int)(uint)output2; j++)
			{
				array4[j] = NativeOnnxValueHelper.StringFromNativeUtf8(array3[j]);
			}
			TensorTypeAndShape typeAndShape = new TensorTypeAndShape(elementType, array2, array4);
			return new NodeMetadata(valueType, typeAndShape);
		}

		~InferenceSession()
		{
			Dispose(disposing: false);
		}

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected virtual void Dispose(bool disposing)
		{
			if (!_disposed)
			{
				DisposeImpl(disposing);
			}
		}

		private void DisposeImpl(bool disposing)
		{
			if (disposing)
			{
				if (_namesMemoryPtrs != null)
				{
					foreach (IntPtr namesMemoryPtr in _namesMemoryPtrs)
					{
						Marshal.FreeHGlobal(namesMemoryPtr);
					}
					_namesMemoryPtrs = null;
				}
				if (_builtInSessionOptions != null)
				{
					_builtInSessionOptions.Dispose();
					_builtInSessionOptions = null;
				}
				if (_builtInRunOptions != null)
				{
					_builtInRunOptions.Dispose();
					_builtInRunOptions = null;
				}
			}
			if (_nativeHandle != IntPtr.Zero)
			{
				NativeMethods.OrtReleaseSession(_nativeHandle);
				_nativeHandle = IntPtr.Zero;
			}
			_disposed = true;
		}
	}
	public class TensorTypeAndShape
	{
		public TensorElementType ElementDataType { get; }

		public int[] Dimensions { get; }

		public string[] SymbolicDimensions { get; }

		public TensorElementTypeInfo ElementTypeInfo { get; }

		internal TensorTypeAndShape(TensorElementType elementType, int[] dimensions, string[] symbolicDimensions)
		{
			ElementTypeInfo = TensorBase.GetElementTypeInfo(elementType);
			if (ElementTypeInfo == null)
			{
				throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "Unregistered TensorElementType value of: " + elementType);
			}
			ElementDataType = elementType;
			Dimensions = dimensions;
			SymbolicDimensions = symbolicDimensions;
		}
	}
	public class SequenceMetadata
	{
		public NodeMetadata ElementMeta { get; }

		internal SequenceMetadata(NodeMetadata elementData)
		{
			ElementMeta = elementData;
		}
	}
	public class OptionalMetadata
	{
		public NodeMetadata ElementMeta { get; }

		internal OptionalMetadata(NodeMetadata elementData)
		{
			ElementMeta = elementData;
		}
	}
	public class MapMetadata
	{
		public TensorElementType KeyDataType { get; }

		public NodeMetadata ValueMetadata { get; }

		internal MapMetadata(TensorElementType keyDataType, NodeMetadata valueMetadata)
		{
			KeyDataType = keyDataType;
			ValueMetadata = valueMetadata;
		}
	}
	public class NodeMetadata
	{
		private readonly object _metadata;

		public OnnxValueType OnnxValueType { get; }

		internal IntPtr ZeroTerminatedName { get; set; }

		public int[] Dimensions
		{
			get
			{
				CheckTensor();
				return (_metadata as TensorTypeAndShape).Dimensions;
			}
		}

		public string[] SymbolicDimensions
		{
			get
			{
				CheckTensor();
				return (_metadata as TensorTypeAndShape).SymbolicDimensions;
			}
		}

		public Type ElementType
		{
			get
			{
				CheckTensor();
				return (_metadata as TensorTypeAndShape).ElementTypeInfo.TensorType;
			}
		}

		public TensorElementType ElementDataType
		{
			get
			{
				CheckTensor();
				return (_metadata as TensorTypeAndShape).ElementDataType;
			}
		}

		public bool IsString
		{
			get
			{
				CheckTensor();
				return (_metadata as TensorTypeAndShape).ElementTypeInfo.IsString;
			}
		}

		public bool IsTensor => OnnxValueType == OnnxValueType.ONNX_TYPE_TENSOR || OnnxValueType == OnnxValueType.ONNX_TYPE_SPARSETENSOR;

		internal NodeMetadata(OnnxValueType onnxValueType, TensorTypeAndShape typeAndShape)
		{
			OnnxValueType = onnxValueType;
			CheckTensor();
			_metadata = typeAndShape;
		}

		internal NodeMetadata(MapMetadata mapMetadata)
		{
			OnnxValueType = OnnxValueType.ONNX_TYPE_MAP;
			_metadata = mapMetadata;
		}

		internal NodeMetadata(SequenceMetadata sequenceMetadata)
		{
			OnnxValueType = OnnxValueType.ONNX_TYPE_SEQUENCE;
			_metadata = sequenceMetadata;
		}

		internal NodeMetadata(OptionalMetadata optMetadata)
		{
			OnnxValueType = OnnxValueType.ONNX_TYPE_OPTIONAL;
			_metadata = optMetadata;
		}

		private void CheckTensor()
		{
			if (!IsTensor)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "OnnxValueType must either be a tensor or sparse tensor");
			}
		}

		public MapMetadata AsMapMetadata()
		{
			if (OnnxValueType != OnnxValueType.ONNX_TYPE_MAP)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "Instance does not contain Map metadata");
			}
			return _metadata as MapMetadata;
		}

		public SequenceMetadata AsSequenceMetadata()
		{
			if (OnnxValueType != OnnxValueType.ONNX_TYPE_SEQUENCE)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "Instance does not contain Sequence metadata");
			}
			return _metadata as SequenceMetadata;
		}

		public OptionalMetadata AsOptionalMetadata()
		{
			if (OnnxValueType != OnnxValueType.ONNX_TYPE_OPTIONAL)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "Instance does not contain Optional metadata");
			}
			return _metadata as OptionalMetadata;
		}
	}
	public class ModelMetadata
	{
		private string _producerName;

		private string _graphName;

		private string _domain;

		private string _description;

		private string _graphDescription;

		private long _version;

		private Dictionary<string, string> _customMetadataMap = new Dictionary<string, string>();

		public string ProducerName => _producerName;

		public string GraphName => _graphName;

		public string Domain => _domain;

		public string Description => _description;

		public string GraphDescription => _graphDescription;

		public long Version => _version;

		public Dictionary<string, string> CustomMetadataMap => _customMetadataMap;

		internal unsafe ModelMetadata(InferenceSession session)
		{
			OrtAllocator defaultInstance = OrtAllocator.DefaultInstance;
			NativeApiStatus.VerifySuccess(NativeMethods.OrtSessionGetModelMetadata(session.Handle, out var modelMetadata));
			try
			{
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetProducerName(modelMetadata, defaultInstance.Pointer, out var value));
				_producerName = NativeOnnxValueHelper.StringFromNativeUtf8(value, defaultInstance);
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetGraphName(modelMetadata, defaultInstance.Pointer, out var value2));
				_graphName = NativeOnnxValueHelper.StringFromNativeUtf8(value2, defaultInstance);
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetDomain(modelMetadata, defaultInstance.Pointer, out var value3));
				_domain = NativeOnnxValueHelper.StringFromNativeUtf8(value3, defaultInstance);
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetDescription(modelMetadata, defaultInstance.Pointer, out var value4));
				_description = NativeOnnxValueHelper.StringFromNativeUtf8(value4, defaultInstance);
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetGraphDescription(modelMetadata, defaultInstance.Pointer, out var value5));
				_graphDescription = NativeOnnxValueHelper.StringFromNativeUtf8(value5, defaultInstance);
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetVersion(modelMetadata, out _version));
				NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataGetCustomMetadataMapKeys(modelMetadata, defaultInstance.Pointer, out var keys, out var numKeys));
				try
				{
					Span<IntPtr> span = new Span<IntPtr>(keys.ToPointer(), (int)numKeys);
					using DisposableList<OrtMemoryAllocation> disposableList = new DisposableList<OrtMemoryAllocation>((int)numKeys);
					Span<IntPtr> span2 = span;
					for (int i = 0; i < span2.Length; i++)
					{
						IntPtr pointer = span2[i];
						disposableList.Add(new OrtMemoryAllocation(defaultInstance, pointer, 0u));
					}
					Span<IntPtr> span3 = span;
					for (int j = 0; j < span3.Length; j++)
					{
						IntPtr intPtr = span3[j];
						NativeApiStatus.VerifySuccess(NativeMethods.OrtModelMetadataLookupCustomMetadataMap(modelMetadata, defaultInstance.Pointer, intPtr, out var value6));
						string value7 = NativeOnnxValueHelper.StringFromNativeUtf8(value6, defaultInstance);
						string key = NativeOnnxValueHelper.StringFromNativeUtf8(intPtr);
						_customMetadataMap[key] = value7;
					}
				}
				finally
				{
					defaultInstance.FreeMemory(keys);
				}
			}
			finally
			{
				NativeMethods.OrtReleaseModelMetadata(modelMetadata);
			}
		}
	}
	internal class ManagedTypeProjection
	{
		internal static OrtValue CreateProjection(NamedOnnxValue namedOnnxValue, NodeMetadata metadata)
		{
			NodeMetadata nodeMetadata = metadata;
			if (metadata.OnnxValueType == OnnxValueType.ONNX_TYPE_OPTIONAL)
			{
				nodeMetadata = metadata.AsOptionalMetadata().ElementMeta;
			}
			if (namedOnnxValue.ValueType != nodeMetadata.OnnxValueType)
			{
				throw new OnnxRuntimeException(ErrorCode.RuntimeException, $"NamedOnnxValue: {namedOnnxValue.Name} has value type: {namedOnnxValue.ValueType}" + $" expected: {nodeMetadata.OnnxValueType} after optional type adjustment");
			}
			return namedOnnxValue.ValueType switch
			{
				OnnxValueType.ONNX_TYPE_TENSOR => CreateTensorProjection(namedOnnxValue, nodeMetadata), 
				OnnxValueType.ONNX_TYPE_SEQUENCE => CreateSequenceProjection(namedOnnxValue, nodeMetadata), 
				OnnxValueType.ONNX_TYPE_MAP => CreateMapProjection(namedOnnxValue, nodeMetadata), 
				_ => throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "ManagedTypeProjection can only project tensors, sequences, maps and optional types"), 
			};
		}

		private static OrtValue CreateSequenceProjection(NamedOnnxValue namedOnnxValue, NodeMetadata metadata)
		{
			NodeMetadata elementMeta = metadata.AsSequenceMetadata().ElementMeta;
			OnnxValueType onnxValueType = elementMeta.OnnxValueType;
			IEnumerable<NamedOnnxValue> enumerable = namedOnnxValue.AsEnumerable<NamedOnnxValue>() ?? throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "NamedOnnxValue: " + namedOnnxValue.Name + " sequence does not contain NamedOnnxValue elements");
			int count = 0;
			if (enumerable is ICollection<NamedOnnxValue> collection)
			{
				count = collection.Count;
			}
			DisposableList<OrtValue> compositeMembers = new DisposableList<OrtValue>(count);
			try
			{
				foreach (NamedOnnxValue item in enumerable)
				{
					if (onnxValueType != item.ValueType)
					{
						throw new OnnxRuntimeException(ErrorCode.InvalidArgument, $"NamedOnnxValue: {namedOnnxValue.Name} sequence element expected to be {onnxValueType}, received {item.ValueType}");
					}
					compositeMembers.Add(CreateProjection(item, elementMeta));
				}
				return OrtValue.CreateSequence(ref compositeMembers);
			}
			catch (Exception)
			{
				compositeMembers?.Dispose();
				throw;
			}
		}

		private static OrtValue CreateMapProjection(NamedOnnxValue node, NodeMetadata elementMeta)
		{
			MapMetadata mapMetadata = elementMeta.AsMapMetadata();
			NodeMetadata valueMetadata = mapMetadata.ValueMetadata;
			if (valueMetadata.OnnxValueType != OnnxValueType.ONNX_TYPE_TENSOR)
			{
				throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "Node: " + node.Name + " onnxruntime only supports maps with primitive types values");
			}
			Span<OrtValue> disposables = new OrtValue[2];
			DisposableArray<OrtValue> disposableArray = new DisposableArray<OrtValue>(disposables);
			try
			{
				TensorBase dictionaryKeys = node.GetDictionaryKeys();
				disposables[0] = OrtValue.CreateFromTensorObject(dictionaryKeys, out var elementType);
				if (elementType != mapMetadata.KeyDataType)
				{
					throw new OnnxRuntimeException(ErrorCode.InvalidArgument, $"Map key data type supplied: {elementType} metadata expected: {mapMetadata.KeyDataType}");
				}
				TensorBase dictionaryValues = node.GetDictionaryValues();
				disposables[1] = OrtValue.CreateFromTensorObject(dictionaryValues, out var elementType2);
				if (elementType2 != valueMetadata.ElementDataType)
				{
					throw new OnnxRuntimeException(ErrorCode.InvalidArgument, $"Map value data type supplied: {elementType2} metadata expected: {valueMetadata.ElementDataType}");
				}
				return OrtValue.CreateMap(ref disposables[0], ref disposables[1]);
			}
			catch (Exception)
			{
				disposableArray.Dispose();
				throw;
			}
		}

		private static OrtValue CreateTensorProjection(NamedOnnxValue node, NodeMetadata elementMeta)
		{
			if (!(node.Value is TensorBase))
			{
				throw new OnnxRuntimeException(ErrorCode.InvalidArgument, $"NamedOnnxValue contains: {node.Value.GetType()}, expecting a Tensor<T>");
			}
			TensorElementType elementType;
			OrtValue ortValue = OrtValue.CreateFromTensorObject(node.Value as TensorBase, out elementType);
			try
			{
				if (elementType != elementMeta.ElementDataType)
				{
					throw new OnnxRuntimeException(ErrorCode.InvalidArgument, $"Tensor element data type discovered: {elementType} metadata expected: {elementMeta.ElementDataType}");
				}
			}
			catch (Exception)
			{
				ortValue.Dispose();
				throw;
			}
			return ortValue;
		}
	}
	internal class MapHelper
	{
		internal TensorBase Keys { get; }

		internal TensorBase Values { get; }

		internal MapHelper(TensorBase keys, TensorBase values)
		{
			Keys = keys;
			Values = values;
		}
	}
	public class NamedOnnxValue
	{
		private object _value;

		private string _name;

		private MapHelper _mapHelper;

		public OnnxValueType ValueType { get; internal set; }

		public string Name
		{
			get
			{
				return _name;
			}
			set
			{
				_name = value;
			}
		}

		public object Value
		{
			get
			{
				return _value;
			}
			set
			{
				_value = value;
			}
		}

		[Obsolete("Use constructors with valueType or static factory methods")]
		protected NamedOnnxValue(string name, object value)
		{
			_name = name;
			_value = value;
			ValueType = OnnxValueType.ONNX_TYPE_UNKNOWN;
		}

		internal NamedOnnxValue(string name, object value, OnnxValueType valueType)
		{
			_name = name;
			_value = value;
			ValueType = valueType;
			if (valueType == OnnxValueType.ONNX_TYPE_MAP)
			{
				throw new OnnxRuntimeException(ErrorCode.InvalidArgument, "Use another __ctor for maps");
			}
		}

		internal NamedOnnxValue(string name, object value, MapHelper helper)
		{
			_name = name;
			_value = value;
			ValueType = OnnxValueType.ONNX_TYPE_MAP;
			_mapHelper = helper;
		}

		public static NamedOnnxValue CreateFromTensor<T>(string name, Tensor<T> value)
		{
			return new NamedOnnxValue(name, value, OnnxValueType.ONNX_TYPE_TENSOR);
		}

		public static NamedOnnxValue CreateFromSequence<T>(string name, IEnumerable<T> value)
		{
			return new NamedOnnxValue(name, value, OnnxValueType.ONNX_TYPE_SEQUENCE);
		}

		public static NamedOnnxValue CreateFromMap<K, V>(string name, IDictionary<K, V> value)
		{
			return CreateFromMap(name, value.Keys, value.Values);
		}

		internal static NamedOnnxValue CreateFromMap<K, V>(string name, ICollection<K> keys, ICollection<V> values)
		{
			DenseTensor<K> keys2 = new DenseTensor<K>(keys.ToArray(), new int[1] { keys.Count });
			DenseTensor<V> values2 = new DenseTensor<V>(values.ToArray(), new int[1] { values.Count });
			return new NamedOnnxValue(name, values, new MapHelper(keys2, values2));
		}

		public Tensor<T> AsTensor<T>()
		{
			return _value as Tensor<T>;
		}

		public IEnumerable<T> AsEnumerable<T>()
		{
			return _value as IEnumerable<T>;
		}

		public IDictionary<K, V> AsDictionary<K, V>()
		{
			return _value as IDictionary<K, V>;
		}

		internal virtual IntPtr InputToOrtValueHandle(NodeMetadata metadata, out IDisposable memoryOwner)
		{
			return ((OrtValue)(memoryOwner = ManagedTypeProjection.CreateProjection(this, metadata))).Handle;
		}

		internal virtual IntPtr OutputToOrtValueHandle(NodeMetadata metadata, out IDisposable memoryOwner)
		{
			if (metadata.OnnxValueType == OnnxValueType.ONNX_TYPE_TENSOR)
			{
				return ((OrtValue)(memoryOwner = ManagedTypeProjection.CreateProjection(this, metadata))).Handle;
			}
			if (metadata.OnnxValueType == OnnxValueType.ONNX_TYPE_OPTIONAL)
			{
				NodeMetadata elementMeta = metadata.AsOptionalMetadata().ElementMeta;
				if (elementMeta.OnnxValueType == OnnxValueType.ONNX_TYPE_TENSOR)
				{
					return ((OrtValue)(memoryOwner = ManagedTypeProjection.CreateProjection(this, metadata))).Handle;
				}
			}
			throw new OnnxRuntimeException(ErrorCode.NotImplemented, $"Can not create output OrtValue for NamedOnnxValue '{metadata.OnnxValueType}' type." + " Only tensors can be pre-allocated for outputs  Use Run() overloads that return DisposableNamedOnnxValue to get access to all Onnx value types that may be returned as output.");
		}

		internal TensorBase GetDictionaryKeys()
		{
			if (ValueType != OnnxValueType.ONNX_TYPE_MAP)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "This NamedOnnxValue instance does not contain a dictionary");
			}
			return _mapHelper.Keys;
		}

		internal TensorBase GetDictionaryValues()
		{
			if (ValueType != OnnxValueType.ONNX_TYPE_MAP)
			{
				throw new OnnxRuntimeException(ErrorCode.Fail, "This NamedOnnxValue instance does not contain a dictionary");
			}
			return _mapHelper.Values;
		}
	}
	internal class NativeApiStatus
	{
		private static string GetErrorMessage(IntPtr status)
		{
			IntPtr nativeUtf = NativeMethods.OrtGetErrorMessage(status);
			return NativeOnnxValueHelper.StringFromNativeUtf8(nativeUtf);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void VerifySuccess(IntPtr nativeStatus)
		{
			if (nativeStatus != IntPtr.Zero)
			{
				try
				{
					ErrorCode errorCode = NativeMethods.OrtGetErrorCode(nativeStatus);
					string errorMessage = GetErrorMessage(nativeStatus);
					throw new OnnxRuntimeException(errorCode, errorMessage);
				}
				finally
				{
					NativeMethods.OrtReleaseStatus(nativeStatus);
				}
			}
		}
	}
	public struct OrtApiBase
	{
		public IntPtr GetApi;

		public IntPtr GetVersionString;
	}
	public struct OrtApi
	{
		public IntPtr CreateStatus;

		public IntPtr GetErrorCode;

		public IntPtr GetErrorMessage;

		public IntPtr CreateEnv;

		public IntPtr CreateEnvWithCustomLogger;

		public IntPtr EnableTelemetryEvents;

		public IntPtr DisableTelemetryEvents;

		public IntPtr CreateSession;

		public IntPtr CreateSessionFromArray;

		public IntPtr Run;

		public IntPtr CreateSessionOptions;

		public IntPtr SetOptimizedModelFilePath;

		public IntPtr CloneSessionOptions;

		public IntPtr SetSessionExecutionMode;

		public IntPtr EnableProfiling;

		public IntPtr DisableProfiling;

		public IntPtr EnableMemPattern;

		public IntPtr DisableMemPattern;

		public IntPtr EnableCpuMemArena;

		public IntPtr DisableCpuMemArena;

		public IntPtr SetSessionLogId;

		public IntPtr SetSessionLogVerbosityLevel;

		public IntPtr SetSessionLogSeverityLevel;

		public IntPtr SetSessionGraphOptimizationLevel;

		public IntPtr SetIntraOpNumThreads;

		public IntPtr SetInterOpNumThreads;

		public IntPtr CreateCustomOpDomain;

		public IntPtr CustomOpDomain_Add;

		public IntPtr AddCustomOpDomain;

		public IntPtr RegisterCustomOpsLibrary;

		public IntPtr SessionGetInputCount;

		public IntPtr SessionGetOutputCount;

		public IntPtr SessionGetOverridableInitializerCount;

		public IntPtr SessionGetInputTypeInfo;

		public IntPtr SessionGetOutputTypeInfo;

		public IntPtr SessionGetOverridableInitializerTypeInfo;

		public IntPtr SessionGetInputName;

		public IntPtr SessionGetOutputName;

		public IntPtr SessionGetOverridableInitializerName;

		public IntPtr CreateRunOptions;

		public IntPtr RunOptionsSetRunLogVerbosityLevel;

		public IntPtr RunOptionsSetRunLogSeverityLevel;

		public IntPtr RunOptionsSetRunTag;

		public IntPtr RunOptionsGetRunLogVerbosityLevel;

		public IntPtr RunOptionsGetRunLogSeverityLevel;

		public IntPtr RunOptionsGetRunTag;

		public IntPtr RunOptionsSetTerminate;

		public IntPtr RunOptionsUnsetTerminate;

		public IntPtr CreateTensorAsOrtValue;

		public IntPtr CreateTensorWithDataAsOrtValue;

		public IntPtr IsTensor;

		public IntPtr GetTensorMutableData;

		public IntPtr FillStringTensor;

		public IntPtr GetStringTensorDataLength;

		public IntPtr GetStringTensorContent;

		public IntPtr CastTypeInfoToTensorInfo;

		public IntPtr GetOnnxTypeFromTypeInfo;

		public IntPtr CreateTensorTypeAndShapeInfo;

		public IntPtr SetTensorElementType;

		public IntPtr SetDimensions;

		public IntPtr GetTensorElementType;

		public IntPtr GetDimensionsCount;

		public IntPtr GetDimensions;

		public IntPtr GetSymbolicDimensions;

		public IntPtr GetTensorShapeElementCount;

		public IntPtr GetTensorTypeAndShape;

		public IntPtr GetTypeInfo;

		public IntPtr GetValueType;

		public IntPtr CreateMemoryInfo;

		public IntPtr CreateCpuMemoryInfo;

		public IntPtr CompareMemoryInfo;

		public IntPtr MemoryInfoGetName;

		public IntPtr MemoryInfoGetId;

		public IntPtr MemoryInfoGetMemType;

		public IntPtr MemoryInfoGetType;

		public IntPtr AllocatorAlloc;

		public IntPtr AllocatorFree;

		public IntPtr AllocatorGetInfo;

		public IntPtr GetAllocatorWithDefaultOptions;

		public IntPtr AddFreeDimensionOverride;

		public IntPtr GetValue;

		public IntPtr GetValueCount;

		public IntPtr CreateValue;

		public IntPtr CreateOpaqueValue;

		public IntPtr GetOpaqueValue;

		public IntPtr KernelInfoGetAttribute_float;

		public IntPtr KernelInfoGetAttribute_int64;

		public IntPtr KernelInfoGetAttribute_string;

		public IntPtr KernelContext_GetInputCount;

		public IntPtr KernelContext_GetOutputCount;

		public IntPtr KernelContext_GetInput;

		public IntPtr KernelContext_GetOutput;

		public IntPtr ReleaseEnv;

		public IntPtr ReleaseStatus;

		public IntPtr ReleaseMemoryInfo;

		public IntPtr ReleaseSession;

		public IntPtr ReleaseValue;

		public IntPtr ReleaseRunOptions;

		public IntPtr ReleaseTypeInfo;

		public IntPtr ReleaseTensorTypeAndShapeInfo;

		public IntPtr ReleaseSessionOptions;

		public IntPtr ReleaseCustomOpDomain;

		public IntPtr GetDenotationFromTypeInfo;

		public IntPtr CastTypeInfoToMapTypeInfo;

		public IntPtr CastTypeInfoToSequenceTypeInfo;

		public IntPtr GetMapKeyType;

		public IntPtr GetMapValueType;

		public IntPtr GetSequenceElementType;

		public IntPtr ReleaseMapTypeInfo;

		public IntPtr ReleaseSequenceTypeInfo;

		public IntPtr SessionEndProfiling;

		public IntPtr SessionGetModelMetadata;

		public IntPtr ModelMetadataGetProducerName;

		public IntPtr ModelMetadataGetGraphName;

		public IntPtr ModelMetadataGetDomain;

		public IntPtr ModelMetadataGetDescription;

		public IntPtr ModelMetadataLookupCustomMetadataMap;

		public IntPtr ModelMetadataGetVersion;

		public IntPtr ReleaseModelMetadata;

		public IntPtr CreateEnvWithGlobalThreadPools;

		public IntPtr DisablePerSessionThreads;

		public IntPtr CreateThreadingOptions;

		public IntPtr ReleaseThreadingOptions;

		public IntPtr ModelMetadataGetCustomMetadataMapKeys;

		public IntPtr AddFreeDimensionOverrideByName;

		public IntPtr GetAvailableProviders;

		public IntPtr ReleaseAvailableProviders;

		public IntPtr GetStringTensorElementLength;

		public IntPtr GetStringTensorElement;

		public IntPtr FillStringTensorElement;

		public IntPtr AddSessionConfigEntry;

		public IntPtr CreateAllocator;

		public IntPtr ReleaseAllocator;

		public IntPtr RunWithBinding;

		public IntPtr CreateIoBinding;

		public IntPtr ReleaseIoBinding;

		public IntPtr BindInput;

		public IntPtr BindOutput;

		public IntPtr BindOutputToDevice;

		public IntPtr GetBoundOutputNames;

		public IntPtr GetBoundOutputValues;

		public IntPtr ClearBoundInputs;

		public IntPtr ClearBoundOutputs;

		public IntPtr TensorAt;

		public IntPtr CreateAndRegisterAllocator;

		public IntPtr SetLanguageProjection;

		public IntPtr SessionGetProfilingStartTimeNs;

		public IntPtr SetGlobalIntraOpNumThreads;

		public IntPtr SetGlobalInterOpNumThreads;

		public IntPtr SetGlobalSpinControl;

		public IntPtr AddInitializer;

		public IntPtr CreateEnvWithCustomLoggerAndGlobalThreadPools;

		public IntPtr SessionOptionsAppendExecutionProvider_CUDA;

		public IntPtr SessionOptionsAppendExecutionProvider_ROCM;

		public IntPtr SessionOptionsAppendExecutionProvider_OpenVINO;

		public IntPtr SetGlobalDenormalAsZero;

		public IntPtr CreateArenaCfg;

		public IntPtr ReleaseArenaCfg;

		public IntPtr ModelMetadataGetGraphDescription;

		public IntPtr SessionOptionsAppendExecutionProvider_TensorRT;

		public IntPtr SetCurrentGpuDeviceId;

		public IntPtr GetCurrentGpuDeviceId;

		public IntPtr KernelInfoGetAttributeArray_float;

		public IntPtr KernelInfoGetAttributeArray_int64;

		public IntPtr CreateArenaCfgV2;

		public IntPtr AddRunConfigEntry;

		public IntPtr CreatePrepackedWeightsContainer;

		public IntPtr ReleasePrepackedWeightsContainer;

		public IntPtr CreateSessionWithPrepackedWeightsContainer;

		public IntPtr CreateSessionFromArrayWithPrepackedWeightsContainer;

		public IntPtr SessionOptionsAppendExecutionProvider_TensorRT_V2;

		public IntPtr CreateTensorRTProviderOptions;

		public IntPtr UpdateTensorRTProviderOptions;

		public IntPtr GetTensorRTProviderOptionsAsString;

		public IntPtr ReleaseTensorRTProviderOptions;

		public IntPtr EnableOrtCustomOps;

		public IntPtr RegisterAllocator;

		public IntPtr UnregisterAllocator;

		public IntPtr IsSparseTensor;

		public IntPtr CreateSparseTensorAsOrtValue;

		public IntPtr FillSparseTensorCoo;

		public IntPtr FillSparseTensorCsr;

		public IntPtr FillSparseTensorBlockSparse;

		public IntPtr CreateSparseTensorWithValuesAsOrtValue;

		public IntPtr UseCooIndices;

		public IntPtr UseCsrIndices;

		public IntPtr UseBlockSparseIndices;

		public IntPtr GetSparseTensorFormat;

		public IntPtr GetSparseTensorValuesTypeAndShape;

		public IntPtr GetSparseTensorValues;

		public IntPtr GetSparseTensorIndicesTypeShape;

		public IntPtr GetSparseTensorIndices;

		public IntPtr HasValue;

		public IntPtr KernelContext_GetGPUComputeStream;

		public IntPtr GetTensorMemoryInfo;

		public IntPtr GetExecutionProviderApi;

		public IntPtr SessionOptionsSetCustomCreateThreadFn;

		public IntPtr SessionOptionsSetCustomThreadCreationOptions;

		public IntPtr SessionOptionsSetCustomJoinThreadFn;

		public IntPtr SetGlobalCustomCreateThreadFn;

		public IntPtr SetGlobalCustomThreadCreationOptions;

		public IntPtr SetGlobalCustomJoinThreadFn;

		public IntPtr SynchronizeBoundInputs;

		public IntPtr SynchronizeBoundOutputs;

		public IntPtr SessionOptionsAppendExecutionProvider_CUDA_V2;

		public IntPtr CreateCUDAProviderOptions;

		public IntPtr UpdateCUDAProviderOptions;

		public IntPtr GetCUDAProviderOptionsAsString;

		public IntPtr ReleaseCUDAProviderOptions;

		public IntPtr SessionOptionsAppendExecutionProvider_MIGraphX;

		public IntPtr AddExternalInitializers;

		public IntPtr CreateOpAttr;

		public IntPtr ReleaseOpAttr;

		public IntPtr CreateOp;

		public IntPtr InvokeOp;

		public IntPtr ReleaseOp;

		public IntPtr SessionOptionsAppendExecutionProvider;

		public IntPtr CopyKernelInfo;

		public IntPtr ReleaseKernelInfo;

		public IntPtr GetTrainingApi;

		public IntPtr SessionOptionsAppendExecutionProvider_CANN;

		public IntPtr CreateCANNProviderOptions;

		public IntPtr UpdateCANNProviderOptions;

		public IntPtr GetCANNProviderOptionsAsString;

		public IntPtr ReleaseCANNProviderOptions;

		public IntPtr MemoryInfoGetDeviceType;

		public IntPtr UpdateEnvWithCustomLogLevel;

		public IntPtr SetGlobalIntraOpThreadAffinity;

		public IntPtr RegisterCustomOpsLibrary_V2;

		public IntPtr RegisterCustomOpsUsingFunction;

		public IntPtr KernelInfo_GetInputCount;

		public IntPtr KernelInfo_GetOutputCount;

		public IntPtr KernelInfo_GetInputName;

		public IntPtr KernelInfo_GetOutputName;

		public IntPtr KernelInfo_GetInputTypeInfo;

		public IntPtr KernelInfo_GetOutputTypeInfo;

		public IntPtr KernelInfoGetAttribute_tensor;

		public IntPtr HasSessionConfigEntry;

		public IntPtr GetSessionConfigEntry;

		public IntPtr SessionOptionsAppendExecutionProvider_Dnnl;

		public IntPtr CreateDnnlProviderOptions;

		public IntPtr UpdateDnnlProviderOptions;

		public IntPtr GetDnnlProviderOptionsAsString;

		public IntPtr ReleaseDnnlProviderOptions;

		public IntPtr KernelInfo_GetNodeName;

		public IntPtr KernelInfo_GetLogger;

		public IntPtr KernelContext_GetLogger;

		public IntPtr Logger_LogMessage;

		public IntPtr Logger_GetLoggingSeverityLevel;

		public IntPtr KernelInfoGetConstantInput_tensor;

		public IntPtr CastTypeInfoToOptionalTypeInfo;

		public IntPtr GetOptionalContainedTypeInfo;

		public IntPtr GetResizedStringTensorElementBuffer;

		public IntPtr KernelContext_GetAllocator;

		public IntPtr GetBuildInfoString;

		public IntPtr CreateROCMProviderOptions;

		public IntPtr UpdateROCMProviderOptions;

		public IntPtr GetROCMProviderOptionsAsString;

		public IntPtr ReleaseROCMProviderOptions;

		public IntPtr CreateAndRegisterAllocatorV2;

		public IntPtr RunAsync;
	}
	internal static class NativeMethods
	{
		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate ref OrtApi DOrtGetApi(uint version);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetVersionString();

		internal class NativeLib
		{
			internal const string DllName = "onnxruntime";
		}

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateEnv(OrtLoggingLevel defaultLoggingLevel, byte[] logId, out IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateEnvWithCustomLogger(IntPtr loggingFunction, IntPtr loggerParam, OrtLoggingLevel defaultLoggingLevel, byte[] logId, out IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateEnvWithGlobalThreadPools(OrtLoggingLevel defaultWarningLevel, byte[] logId, IntPtr threadingOptions, out IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateEnvWithCustomLoggerAndGlobalThreadPools(IntPtr loggingFunction, IntPtr loggerParam, OrtLoggingLevel logSeverityLevel, byte[] logId, IntPtr threadingOptions, out IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseEnv(IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtEnableTelemetryEvents(IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtDisableTelemetryEvents(IntPtr env);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtUpdateEnvWithCustomLogLevel(IntPtr env, OrtLoggingLevel custom_log_level);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateTensorRTProviderOptions(out IntPtr trtProviderOptionsInstance);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtUpdateTensorRTProviderOptions(IntPtr trtProviderOptionsInstance, IntPtr[] providerOptionsKeys, IntPtr[] providerOptionsValues, UIntPtr numKeys);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetTensorRTProviderOptionsAsString(IntPtr trtProviderOptionsInstance, IntPtr allocator, out IntPtr ptr);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseTensorRTProviderOptions(IntPtr trtProviderOptionsInstance);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateCUDAProviderOptions(out IntPtr cudaProviderOptionsInstance);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtUpdateCUDAProviderOptions(IntPtr cudaProviderOptionsInstance, IntPtr[] providerOptionsKeys, IntPtr[] providerOptionsValues, UIntPtr numKeys);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetCUDAProviderOptionsAsString(IntPtr cudaProviderOptionsInstance, IntPtr allocator, out IntPtr ptr);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseCUDAProviderOptions(IntPtr cudaProviderOptionsInstance);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateROCMProviderOptions(out IntPtr rocmProviderOptionsInstance);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtUpdateROCMProviderOptions(IntPtr rocmProviderOptionsInstance, IntPtr[] providerOptionsKeys, IntPtr[] providerOptionsValues, UIntPtr numKeys);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetROCMProviderOptionsAsString(IntPtr rocmProviderOptionsInstance, IntPtr allocator, out IntPtr ptr);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseROCMProviderOptions(IntPtr rocmProviderOptionsInstance);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate ErrorCode DOrtGetErrorCode(IntPtr status);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetErrorMessage(IntPtr status);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseStatus(IntPtr statusPtr);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateSession(IntPtr environment, byte[] modelPath, IntPtr sessopnOptions, out IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateSessionWithPrepackedWeightsContainer(IntPtr environment, byte[] modelPath, IntPtr sessionOptions, IntPtr prepackedWeightsContainer, out IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateSessionFromArray(IntPtr environment, byte[] modelData, UIntPtr modelSize, IntPtr sessionOptions, out IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateSessionFromArrayWithPrepackedWeightsContainer(IntPtr environment, byte[] modelData, UIntPtr modelSize, IntPtr sessionOptions, IntPtr prepackedWeightsContainer, out IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRun(IntPtr session, IntPtr runOptions, IntPtr[] inputNames, IntPtr[] inputValues, UIntPtr inputCount, IntPtr[] outputNames, UIntPtr outputCount, IntPtr[] outputValues);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunWithBinding(IntPtr session, IntPtr runOptions, IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetInputCount(IntPtr session, out UIntPtr count);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetOutputCount(IntPtr session, out UIntPtr count);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetOverridableInitializerCount(IntPtr session, out UIntPtr count);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetInputName(IntPtr session, UIntPtr index, IntPtr allocator, out IntPtr name);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetOutputName(IntPtr session, UIntPtr index, IntPtr allocator, out IntPtr name);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionEndProfiling(IntPtr session, IntPtr allocator, out IntPtr profile_file);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetOverridableInitializerName(IntPtr session, UIntPtr index, IntPtr allocator, out IntPtr name);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetInputTypeInfo(IntPtr session, UIntPtr index, out IntPtr typeInfo);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetOutputTypeInfo(IntPtr session, UIntPtr index, out IntPtr typeInfo);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetOverridableInitializerTypeInfo(IntPtr session, UIntPtr index, out IntPtr typeInfo);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseTypeInfo(IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseSession(IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetProfilingStartTimeNs(IntPtr session, out UIntPtr startTime);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DCreateAndRegisterAllocatorV2(IntPtr environment, IntPtr provider_type, IntPtr mem_info, IntPtr arena_cfg, IntPtr provider_options_keys, IntPtr provider_options_values, UIntPtr num_keys);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunAsync(IntPtr session, IntPtr runOptions, IntPtr[] inputNames, IntPtr[] inputValues, UIntPtr inputCount, IntPtr[] outputNames, UIntPtr outputCount, IntPtr[] outputValues, IntPtr callback, IntPtr user_data);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateSessionOptions(out IntPtr sessionOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseSessionOptions(IntPtr session);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCloneSessionOptions(IntPtr sessionOptions, out IntPtr output);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetSessionExecutionMode(IntPtr options, ExecutionMode execution_mode);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetOptimizedModelFilePath(IntPtr options, byte[] optimizedModelFilepath);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtEnableProfiling(IntPtr options, byte[] profilePathPrefix);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtDisableProfiling(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtEnableMemPattern(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtDisableMemPattern(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtEnableCpuMemArena(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtDisableCpuMemArena(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetSessionLogId(IntPtr options, byte[] logId);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetSessionLogVerbosityLevel(IntPtr options, int sessionLogVerbosityLevel);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetSessionLogSeverityLevel(IntPtr options, OrtLoggingLevel sessionLogSeverityLevel);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetIntraOpNumThreads(IntPtr options, int intraOpNumThreads);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetInterOpNumThreads(IntPtr options, int interOpNumThreads);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetSessionGraphOptimizationLevel(IntPtr options, GraphOptimizationLevel graphOptimizationLevel);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAddSessionConfigEntry(IntPtr options, byte[] configKey, byte[] configValue);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DSessionOptionsAppendExecutionProvider_TensorRT(IntPtr options, IntPtr trtProviderOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DSessionOptionsAppendExecutionProvider_TensorRT_V2(IntPtr options, IntPtr trtProviderOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DSessionOptionsAppendExecutionProvider_CUDA(IntPtr options, IntPtr cudaProviderOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DSessionOptionsAppendExecutionProvider_CUDA_V2(IntPtr options, IntPtr cudaProviderOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DSessionOptionsAppendExecutionProvider_ROCM(IntPtr options, IntPtr rocmProviderOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAddFreeDimensionOverride(IntPtr options, byte[] dimDenotation, long dimValue);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAddFreeDimensionOverrideByName(IntPtr options, byte[] dimName, long dimValue);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRegisterCustomOpsLibrary(IntPtr options, byte[] libraryPath, out IntPtr libraryHandle);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRegisterCustomOpsLibrary_V2(IntPtr options, byte[] libraryPath);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAddInitializer(IntPtr options, byte[] name, IntPtr ortValue);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DSessionOptionsAppendExecutionProvider(IntPtr options, byte[] providerName, IntPtr[] providerOptionsKeys, IntPtr[] providerOptionsValues, UIntPtr numKeys);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateRunOptions(out IntPtr runOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseRunOptions(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsSetRunLogVerbosityLevel(IntPtr options, int value);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsSetRunLogSeverityLevel(IntPtr options, OrtLoggingLevel value);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsSetRunTag(IntPtr options, byte[] runTag);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsGetRunLogVerbosityLevel(IntPtr options, out int verbosityLevel);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsGetRunLogSeverityLevel(IntPtr options, out OrtLoggingLevel severityLevel);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsGetRunTag(IntPtr options, out IntPtr runtag);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsSetTerminate(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtRunOptionsUnsetTerminate(IntPtr options);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAddRunConfigEntry(IntPtr options, byte[] configKey, byte[] configValue);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateThreadingOptions(out IntPtr threadingOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtReleaseThreadingOptions(IntPtr threadingOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtThreadingOptionsSetGlobalInterOpNumThreads(IntPtr threadingOptions, int numThreads);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtThreadingOptionsSetGlobalIntraOpNumThreads(IntPtr threadingOptions, int numThreads);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtThreadingOptionsSetGlobalDenormalAsZero(IntPtr threadingOptions);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtThreadingOptionsSetGlobalSpinControl(IntPtr threadingOptions, int allowSpinning);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateMemoryInfo(byte[] name, OrtAllocatorType allocatorType, int identifier, OrtMemType memType, out IntPtr allocatorInfo);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateCpuMemoryInfo(OrtAllocatorType allocatorType, OrtMemType memoryType, out IntPtr allocatorInfo);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseMemoryInfo(IntPtr allocatorInfo);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCompareMemoryInfo(IntPtr info1, IntPtr info2, out int result);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtMemoryInfoGetName(IntPtr mem_info, out IntPtr name);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtMemoryInfoGetId(IntPtr mem_info, out int id);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtMemoryInfoGetMemType(IntPtr mem_info, out OrtMemType mem_type);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtMemoryInfoGetType(IntPtr mem_info, out OrtAllocatorType alloc_type);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetAllocatorWithDefaultOptions(out IntPtr allocator);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAllocatorGetInfo(IntPtr ptr, out IntPtr info);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateArenaCfg(UIntPtr maxMemory, int arenaExtendStrategy, int initialChunkSizeBytes, int maxDeadBytesPerChunk, out IntPtr arenaCfg);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseArenaCfg(IntPtr arenaCfg);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateAllocator(IntPtr session, IntPtr info, out IntPtr allocator);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseAllocator(IntPtr allocator);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAllocatorAlloc(IntPtr allocator, UIntPtr size, out IntPtr p);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtAllocatorFree(IntPtr allocator, IntPtr p);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateIoBinding(IntPtr session, out IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtReleaseIoBinding(IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtBindInput(IntPtr io_binding, byte[] name, IntPtr ort_value);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSynchronizeBoundInputs(IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtBindOutput(IntPtr io_binding, byte[] name, IntPtr ort_value);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtBindOutputToDevice(IntPtr io_binding, byte[] name, IntPtr mem_info);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSynchronizeBoundOutputs(IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetBoundOutputNames(IntPtr io_binding, IntPtr allocator, out IntPtr buffer, out IntPtr lengths, out UIntPtr count);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtGetBoundOutputValues(IntPtr io_binding, IntPtr allocator, out IntPtr ortvalues, out UIntPtr count);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtClearBoundInputs(IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtClearBoundOutputs(IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate void DOrtTensorAt(IntPtr io_binding);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtCreateAndRegisterAllocator(IntPtr env, IntPtr memInfo, IntPtr arenaCfg);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSetLanguageProjection(IntPtr environment, int projection);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtSessionGetModelMetadata(IntPtr session, out IntPtr modelMetadata);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtModelMetadataGetProducerName(IntPtr modelMetadata, IntPtr allocator, out IntPtr value);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DOrtModelMetadataGetGraphName(IntPtr modelMetadata, IntPtr allocator, out IntPtr value);

		[UnmanagedFunctionPointer(CallingConvention.Winapi)]
		public delegate IntPtr DO