using System;
using System.Diagnostics;
using System.Globalization;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using FxResources.System.Reflection.Emit.Lightweight;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyDefaultAlias("System.Reflection.Emit.Lightweight")]
[assembly: AssemblyMetadata(".NETFrameworkAssembly", "")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyMetadata("NotSupported", "True")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("System.Reflection.Emit.Lightweight")]
[assembly: AssemblyFileVersion("4.700.19.56404")]
[assembly: AssemblyInformationalVersion("3.1.0+0f7f38c4fd323b26da10cce95f857f77f0f09b48")]
[assembly: AssemblyProduct("Microsoft® .NET Core")]
[assembly: AssemblyTitle("System.Reflection.Emit.Lightweight")]
[assembly: CLSCompliant(true)]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.0.0")]
[module: UnverifiableCode]
namespace FxResources.System.Reflection.Emit.Lightweight
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class SR
	{
		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(SR)));

		internal static string PlatformNotSupported_RefEmitLightweight => GetResourceString("PlatformNotSupported_RefEmitLightweight");

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool UsingResourceKeys()
		{
			return false;
		}

		internal static string GetResourceString(string resourceKey, string defaultString = null)
		{
			if (UsingResourceKeys())
			{
				return defaultString ?? resourceKey;
			}
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text))
			{
				return defaultString;
			}
			return text;
		}

		internal static string Format(string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(provider, resourceFormat, p1, p2, p3);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(provider, resourceFormat, args);
			}
			return resourceFormat;
		}
	}
}
namespace System.Reflection.Emit
{
	public sealed class DynamicMethod : MethodInfo
	{
		public override MethodAttributes Attributes
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override CallingConventions CallingConvention
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override Type DeclaringType
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public bool InitLocals
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override RuntimeMethodHandle MethodHandle
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override string Name
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override Type ReflectedType
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override ParameterInfo ReturnParameter
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override Type ReturnType
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public override ICustomAttributeProvider ReturnTypeCustomAttributes
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
			}
		}

		public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Module m, bool skipVisibility)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, MethodAttributes attributes, CallingConventions callingConvention, Type returnType, Type[] parameterTypes, Type owner, bool skipVisibility)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, Type returnType, Type[] parameterTypes)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, Type returnType, Type[] parameterTypes, bool restrictedSkipVisibility)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, Type returnType, Type[] parameterTypes, Module m)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, Type returnType, Type[] parameterTypes, Module m, bool skipVisibility)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, Type returnType, Type[] parameterTypes, Type owner)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public DynamicMethod(string name, Type returnType, Type[] parameterTypes, Type owner, bool skipVisibility)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public sealed override Delegate CreateDelegate(Type delegateType)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public sealed override Delegate CreateDelegate(Type delegateType, object target)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public ParameterBuilder DefineParameter(int position, ParameterAttributes attributes, string parameterName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override MethodInfo GetBaseDefinition()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override object[] GetCustomAttributes(bool inherit)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override object[] GetCustomAttributes(Type attributeType, bool inherit)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public ILGenerator GetILGenerator()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public ILGenerator GetILGenerator(int streamSize)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override MethodImplAttributes GetMethodImplementationFlags()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override ParameterInfo[] GetParameters()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override object Invoke(object obj, BindingFlags invokeAttr, Binder binder, object[] parameters, CultureInfo culture)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override bool IsDefined(Type attributeType, bool inherit)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}

		public override string ToString()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_RefEmitLightweight);
		}
	}
}

using System;
using System.Diagnostics;
using System.Diagnostics.Tracing;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using FxResources.System.Buffers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyTitle("System.Buffers")]
[assembly: AssemblyDescription("System.Buffers")]
[assembly: AssemblyDefaultAlias("System.Buffers")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyProduct("Microsoft® .NET Framework")]
[assembly: AssemblyCopyright("© Microsoft Corporation.  All rights reserved.")]
[assembly: AssemblyFileVersion("4.6.25519.03")]
[assembly: AssemblyInformationalVersion("4.6.25519.03 built by: dlab-DDVSOWINAGE013. Commit Hash: 8321c729934c0f8be754953439b88e6e1c120c24")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata(".NETFrameworkAssembly", "")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("4.0.2.0")]
[module: UnverifiableCode]
namespace FxResources.System.Buffers
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class SR
	{
		private static ResourceManager s_resourceManager;

		private const string s_resourcesName = "FxResources.System.Buffers.SR";

		private static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(ResourceType));

		internal static string ArgumentException_BufferNotFromPool => GetResourceString("ArgumentException_BufferNotFromPool", null);

		internal static Type ResourceType => typeof(SR);

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool UsingResourceKeys()
		{
			return false;
		}

		internal static string GetResourceString(string resourceKey, string defaultString)
		{
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text, StringComparison.Ordinal))
			{
				return defaultString;
			}
			return text;
		}

		internal static string Format(string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.All)]
	internal class __BlockReflectionAttribute : Attribute
	{
	}
}
namespace System.Buffers
{
	public abstract class ArrayPool<T>
	{
		private static ArrayPool<T> s_sharedInstance;

		public static ArrayPool<T> Shared
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return Volatile.Read(ref s_sharedInstance) ?? EnsureSharedCreated();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static ArrayPool<T> EnsureSharedCreated()
		{
			Interlocked.CompareExchange(ref s_sharedInstance, Create(), null);
			return s_sharedInstance;
		}

		public static ArrayPool<T> Create()
		{
			return new DefaultArrayPool<T>();
		}

		public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket)
		{
			return new DefaultArrayPool<T>(maxArrayLength, maxArraysPerBucket);
		}

		public abstract T[] Rent(int minimumLength);

		public abstract void Return(T[] array, bool clearArray = false);
	}
	[EventSource(Name = "System.Buffers.ArrayPoolEventSource")]
	internal sealed class ArrayPoolEventSource : EventSource
	{
		internal enum BufferAllocatedReason
		{
			Pooled,
			OverMaximumSize,
			PoolExhausted
		}

		internal static readonly System.Buffers.ArrayPoolEventSource Log = new System.Buffers.ArrayPoolEventSource();

		[Event(1, Level = EventLevel.Verbose)]
		internal unsafe void BufferRented(int bufferId, int bufferSize, int poolId, int bucketId)
		{
			EventData* ptr = stackalloc EventData[4];
			ptr->Size = 4;
			ptr->DataPointer = (IntPtr)(&bufferId);
			ptr[1].Size = 4;
			ptr[1].DataPointer = (IntPtr)(&bufferSize);
			ptr[2].Size = 4;
			ptr[2].DataPointer = (IntPtr)(&poolId);
			ptr[3].Size = 4;
			ptr[3].DataPointer = (IntPtr)(&bucketId);
			WriteEventCore(1, 4, ptr);
		}

		[Event(2, Level = EventLevel.Informational)]
		internal unsafe void BufferAllocated(int bufferId, int bufferSize, int poolId, int bucketId, BufferAllocatedReason reason)
		{
			EventData* ptr = stackalloc EventData[5];
			ptr->Size = 4;
			ptr->DataPointer = (IntPtr)(&bufferId);
			ptr[1].Size = 4;
			ptr[1].DataPointer = (IntPtr)(&bufferSize);
			ptr[2].Size = 4;
			ptr[2].DataPointer = (IntPtr)(&poolId);
			ptr[3].Size = 4;
			ptr[3].DataPointer = (IntPtr)(&bucketId);
			ptr[4].Size = 4;
			ptr[4].DataPointer = (IntPtr)(&reason);
			WriteEventCore(2, 5, ptr);
		}

		[Event(3, Level = EventLevel.Verbose)]
		internal void BufferReturned(int bufferId, int bufferSize, int poolId)
		{
			WriteEvent(3, bufferId, bufferSize, poolId);
		}
	}
	internal sealed class DefaultArrayPool<T> : ArrayPool<T>
	{
		private sealed class Bucket
		{
			internal readonly int _bufferLength;

			private readonly T[][] _buffers;

			private readonly int _poolId;

			private SpinLock _lock;

			private int _index;

			internal int Id => GetHashCode();

			internal Bucket(int bufferLength, int numberOfBuffers, int poolId)
			{
				_lock = new SpinLock(Debugger.IsAttached);
				_buffers = new T[numberOfBuffers][];
				_bufferLength = bufferLength;
				_poolId = poolId;
			}

			internal T[] Rent()
			{
				T[][] buffers = _buffers;
				T[] array = null;
				bool lockTaken = false;
				bool flag = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index < buffers.Length)
					{
						array = buffers[_index];
						buffers[_index++] = null;
						flag = array == null;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
				if (flag)
				{
					array = new T[_bufferLength];
					System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
					if (log.IsEnabled())
					{
						log.BufferAllocated(array.GetHashCode(), _bufferLength, _poolId, Id, System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.Pooled);
					}
				}
				return array;
			}

			internal void Return(T[] array)
			{
				if (array.Length != _bufferLength)
				{
					throw new ArgumentException(System.SR.ArgumentException_BufferNotFromPool, "array");
				}
				bool lockTaken = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index != 0)
					{
						_buffers[--_index] = array;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
			}
		}

		private const int DefaultMaxArrayLength = 1048576;

		private const int DefaultMaxNumberOfArraysPerBucket = 50;

		private static T[] s_emptyArray;

		private readonly Bucket[] _buckets;

		private int Id => GetHashCode();

		internal DefaultArrayPool()
			: this(1048576, 50)
		{
		}

		internal DefaultArrayPool(int maxArrayLength, int maxArraysPerBucket)
		{
			if (maxArrayLength <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArrayLength");
			}
			if (maxArraysPerBucket <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArraysPerBucket");
			}
			if (maxArrayLength > 1073741824)
			{
				maxArrayLength = 1073741824;
			}
			else if (maxArrayLength < 16)
			{
				maxArrayLength = 16;
			}
			int id = Id;
			int num = System.Buffers.Utilities.SelectBucketIndex(maxArrayLength);
			Bucket[] array = new Bucket[num + 1];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Bucket(System.Buffers.Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
			}
			_buckets = array;
		}

		public override T[] Rent(int minimumLength)
		{
			if (minimumLength < 0)
			{
				throw new ArgumentOutOfRangeException("minimumLength");
			}
			if (minimumLength == 0)
			{
				return s_emptyArray ?? (s_emptyArray = new T[0]);
			}
			System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
			T[] array = null;
			int num = System.Buffers.Utilities.SelectBucketIndex(minimumLength);
			if (num < _buckets.Length)
			{
				int num2 = num;
				do
				{
					array = _buckets[num2].Rent();
					if (array != null)
					{
						if (log.IsEnabled())
						{
							log.BufferRented(array.GetHashCode(), array.Length, Id, _buckets[num2].Id);
						}
						return array;
					}
				}
				while (++num2 < _buckets.Length && num2 != num + 2);
				array = new T[_buckets[num]._bufferLength];
			}
			else
			{
				array = new T[minimumLength];
			}
			if (log.IsEnabled())
			{
				int hashCode = array.GetHashCode();
				int bucketId = -1;
				log.BufferRented(hashCode, array.Length, Id, bucketId);
				log.BufferAllocated(hashCode, array.Length, Id, bucketId, (num >= _buckets.Length) ? System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.OverMaximumSize : System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.PoolExhausted);
			}
			return array;
		}

		public override void Return(T[] array, bool clearArray = false)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Length == 0)
			{
				return;
			}
			int num = System.Buffers.Utilities.SelectBucketIndex(array.Length);
			if (num < _buckets.Length)
			{
				if (clearArray)
				{
					Array.Clear(array, 0, array.Length);
				}
				_buckets[num].Return(array);
			}
			System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
			if (log.IsEnabled())
			{
				log.BufferReturned(array.GetHashCode(), array.Length, Id);
			}
		}
	}
	internal static class Utilities
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int SelectBucketIndex(int bufferSize)
		{
			uint num = (uint)(bufferSize - 1) >> 4;
			int num2 = 0;
			if (num > 65535)
			{
				num >>= 16;
				num2 = 16;
			}
			if (num > 255)
			{
				num >>= 8;
				num2 += 8;
			}
			if (num > 15)
			{
				num >>= 4;
				num2 += 4;
			}
			if (num > 3)
			{
				num >>= 2;
				num2 += 2;
			}
			if (num > 1)
			{
				num >>= 1;
				num2++;
			}
			return num2 + (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetMaxSizeForBucket(int binIndex)
		{
			return 16 << binIndex;
		}
	}
}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Iced.Intel.BlockEncoderInternal;
using Iced.Intel.DecoderInternal;
using Iced.Intel.EncoderInternal;
using Iced.Intel.FastFormatterInternal;
using Iced.Intel.FormatterInternal;
using Iced.Intel.GasFormatterInternal;
using Iced.Intel.InstructionInfoInternal;
using Iced.Intel.IntelFormatterInternal;
using Iced.Intel.Internal;
using Iced.Intel.MasmFormatterInternal;
using Iced.Intel.NasmFormatterInternal;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("iced project and contributors <https://github.com/icedland>")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright (C) 2018-present iced project and contributors")]
[assembly: AssemblyDescription("x86/x64 disassembler, assembler, instruction decoder")]
[assembly: AssemblyFileVersion("1.17.0.0")]
[assembly: AssemblyInformationalVersion("1.17.0+c7aa5116314e90d391a3350878f9fb99192aafb6")]
[assembly: AssemblyProduct("Iced")]
[assembly: AssemblyTitle("Iced")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/icedland/iced")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.17.0.0")]
[module: UnverifiableCode]
[module: System.Runtime.CompilerServices.NullablePublicOnly(false)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
}
namespace Iced.Intel
{
	public class Assembler
	{
		[Flags]
		private enum PrefixFlags
		{
			None = 0,
			Lock = 1,
			Repe = 2,
			Repne = 4,
			Notrack = 8,
			PreferVex = 0x10,
			PreferEvex = 0x20
		}

		private readonly InstructionList instructions;

		private ulong currentLabelId;

		private Label currentLabel;

		private Label currentAnonLabel;

		private Label nextAnonLabel;

		private bool definedAnonLabel;

		private PrefixFlags prefixFlags;

		public int Bitness { get; }

		public bool PreferVex { get; set; }

		public bool PreferShortBranch { get; set; }

		internal bool InstructionPreferVex
		{
			get
			{
				if ((prefixFlags & (PrefixFlags.PreferVex | PrefixFlags.PreferEvex)) != 0)
				{
					return (prefixFlags & PrefixFlags.PreferVex) != 0;
				}
				return PreferVex;
			}
		}

		public IReadOnlyList<Instruction> Instructions => instructions;

		public Label CurrentLabel => currentLabel;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Label B
		{
			get
			{
				if (currentAnonLabel.IsEmpty)
				{
					throw new InvalidOperationException("No anonymous label has been created yet");
				}
				return currentAnonLabel;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Label F
		{
			get
			{
				if (nextAnonLabel.IsEmpty)
				{
					nextAnonLabel = CreateLabel();
				}
				return nextAnonLabel;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler @lock
		{
			get
			{
				prefixFlags |= PrefixFlags.Lock;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler xacquire
		{
			get
			{
				prefixFlags |= PrefixFlags.Repne;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler xrelease
		{
			get
			{
				prefixFlags |= PrefixFlags.Repe;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler rep
		{
			get
			{
				prefixFlags |= PrefixFlags.Repe;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler repe
		{
			get
			{
				prefixFlags |= PrefixFlags.Repe;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler repz => repe;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler repne
		{
			get
			{
				prefixFlags |= PrefixFlags.Repne;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler repnz => repne;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler bnd
		{
			get
			{
				prefixFlags |= PrefixFlags.Repne;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler notrack
		{
			get
			{
				prefixFlags |= PrefixFlags.Notrack;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler vex
		{
			get
			{
				prefixFlags |= PrefixFlags.PreferVex;
				return this;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public Assembler evex
		{
			get
			{
				prefixFlags |= PrefixFlags.PreferEvex;
				return this;
			}
		}

		public Assembler(int bitness)
		{
			if (bitness != 16 && bitness != 32 && bitness != 64)
			{
				throw new ArgumentOutOfRangeException("bitness");
			}
			Bitness = bitness;
			instructions = new InstructionList();
			currentLabelId = 0uL;
			currentLabel = default(Label);
			currentAnonLabel = default(Label);
			nextAnonLabel = default(Label);
			definedAnonLabel = false;
			prefixFlags = PrefixFlags.None;
			PreferVex = true;
			PreferShortBranch = true;
		}

		public void Reset()
		{
			instructions.Clear();
			currentLabelId = 0uL;
			currentLabel = default(Label);
			currentAnonLabel = default(Label);
			nextAnonLabel = default(Label);
			definedAnonLabel = false;
			prefixFlags = PrefixFlags.None;
		}

		public Label CreateLabel(string? name = null)
		{
			currentLabelId++;
			return new Label(name, currentLabelId);
		}

		public void Label(ref Label label)
		{
			if (label.IsEmpty)
			{
				throw new ArgumentException("Invalid label. Must be created via CreateLabel", "label");
			}
			if (label.InstructionIndex >= 0)
			{
				throw new ArgumentException($"Cannot reuse label. The specified label is already associated with an instruction at index {label.InstructionIndex}.", "label");
			}
			if (!currentLabel.IsEmpty)
			{
				throw new ArgumentException("At most one label per instruction is allowed");
			}
			label.InstructionIndex = instructions.Count;
			currentLabel = label;
		}

		public void AnonymousLabel()
		{
			if (definedAnonLabel)
			{
				throw new InvalidOperationException("At most one anonymous label per instruction is allowed");
			}
			if (nextAnonLabel.IsEmpty)
			{
				currentAnonLabel = CreateLabel();
			}
			else
			{
				currentAnonLabel = nextAnonLabel;
			}
			nextAnonLabel = default(Label);
			definedAnonLabel = true;
		}

		public void AddInstruction(Instruction instruction)
		{
			AddInstruction(ref instruction);
		}

		public void AddInstruction(ref Instruction instruction)
		{
			if (!currentLabel.IsEmpty && definedAnonLabel)
			{
				throw new InvalidOperationException("You can't create both an anonymous label and a normal label");
			}
			if (!currentLabel.IsEmpty)
			{
				instruction.IP = currentLabel.Id;
			}
			else if (definedAnonLabel)
			{
				instruction.IP = currentAnonLabel.Id;
			}
			if (prefixFlags != 0)
			{
				if ((prefixFlags & PrefixFlags.Lock) != 0)
				{
					instruction.HasLockPrefix = true;
				}
				if ((prefixFlags & PrefixFlags.Repe) != 0)
				{
					instruction.HasRepePrefix = true;
				}
				else if ((prefixFlags & PrefixFlags.Repne) != 0)
				{
					instruction.HasRepnePrefix = true;
				}
				if ((prefixFlags & PrefixFlags.Notrack) != 0)
				{
					instruction.SegmentPrefix = Register.DS;
				}
			}
			instructions.Add(in instruction);
			currentLabel = default(Label);
			definedAnonLabel = false;
			prefixFlags = PrefixFlags.None;
		}

		private void AddInstruction(Instruction instruction, AssemblerOperandFlags flags)
		{
			if (flags != 0)
			{
				if ((flags & AssemblerOperandFlags.Broadcast) != 0)
				{
					instruction.IsBroadcast = true;
				}
				if ((flags & AssemblerOperandFlags.Zeroing) != 0)
				{
					instruction.ZeroingMasking = true;
				}
				if ((flags & AssemblerOperandFlags.K7) != 0)
				{
					instruction.OpMask = (Register)(173 + ((int)(flags & AssemblerOperandFlags.K7) >> 6));
				}
				if ((flags & AssemblerOperandFlags.SuppressAllExceptions) != 0)
				{
					instruction.SuppressAllExceptions = true;
				}
				if ((flags & AssemblerOperandFlags.RoundControlMask) != 0)
				{
					instruction.RoundingControl = (RoundingControl)((int)(flags & AssemblerOperandFlags.RoundControlMask) >> 3);
				}
			}
			AddInstruction(ref instruction);
		}

		public void db(byte[] array)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException_array();
			}
			db(array, 0, array.Length);
		}

		public void db(byte[] array, int index, int length)
		{
			if (array == null)
			{
				ThrowHelper.ThrowArgumentNullException_array();
			}
			if (index < 0)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_index();
			}
			if (length < 0 || (uint)(index + length) > (uint)array.Length)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException_length();
			}
			int result;
			int num = Math.DivRem(length, 16, out result);
			int num2 = index;
			for (int i = 0; i < num; i++)
			{
				AddInstruction(Instruction.CreateDeclareByte(array, num2, 16));
				num2 += 16;
			}
			if (result > 0)
			{
				AddInstruction(Instruction.CreateDeclareByte(array, num2, result));
			}
		}

		public void call(ushort selector, uint offset)
		{
			AddInstruction(Instruction.CreateBranch((Bitness >= 32) ? Code.Call_ptr1632 : Code.Call_ptr1616, selector, offset));
		}

		public void jmp(ushort selector, uint offset)
		{
			AddInstruction(Instruction.CreateBranch((Bitness >= 32) ? Code.Jmp_ptr1632 : Code.Jmp_ptr1616, selector, offset));
		}

		public void xlatb()
		{
			MemoryOperand memory = new MemoryOperand(Bitness switch
			{
				64 => Register.RBX, 
				32 => Register.EBX, 
				_ => Register.BX, 
			}, Register.AL);
			AddInstruction(Instruction.Create(Code.Xlat_m8, in memory));
		}

		public void nop(int sizeInBytes)
		{
			if (sizeInBytes < 0)
			{
				throw new ArgumentOutOfRangeException("sizeInBytes");
			}
			if (prefixFlags != 0)
			{
				throw new InvalidOperationException("No prefixes are allowed");
			}
			if (sizeInBytes != 0)
			{
				int result;
				int num = Math.DivRem(sizeInBytes, 9, out result);
				for (int i = 0; i < num; i++)
				{
					AppendNop(9);
				}
				if (result > 0)
				{
					AppendNop(result);
				}
			}
			void AppendNop(int amount)
			{
				switch (amount)
				{
				case 1:
					db(144);
					break;
				case 2:
					db(102, 144);
					break;
				case 3:
					db(15, 31, 0);
					break;
				case 4:
					db(15, 31, 64, 0);
					break;
				case 5:
					if (Bitness != 16)
					{
						db(15, 31, 68, 0, 0);
					}
					else
					{
						db(15, 31, 128, 0, 0);
					}
					break;
				case 6:
					if (Bitness != 16)
					{
						db(102, 15, 31, 68, 0, 0);
					}
					else
					{
						db(102, 15, 31, 128, 0, 0);
					}
					break;
				case 7:
					if (Bitness != 16)
					{
						db(15, 31, 128, 0, 0, 0, 0);
					}
					else
					{
						db(103, 102, 15, 31, 68, 0, 0);
					}
					break;
				case 8:
					if (Bitness != 16)
					{
						db(15, 31, 132, 0, 0, 0, 0, 0);
					}
					else
					{
						db(103, 15, 31, 128, 0, 0, 0, 0);
					}
					break;
				case 9:
					if (Bitness != 16)
					{
						db(102, 15, 31, 132, 0, 0, 0, 0, 0);
					}
					else
					{
						db(103, 15, 31, 132, 0, 0, 0, 0, 0);
					}
					break;
				}
			}
		}

		public AssemblerResult Assemble(CodeWriter writer, ulong rip, BlockEncoderOptions options = BlockEncoderOptions.None)
		{
			if (!TryAssemble(writer, rip, out string errorMessage, out AssemblerResult assemblerResult, options))
			{
				throw new InvalidOperationException(errorMessage);
			}
			return assemblerResult;
		}

		public bool TryAssemble(CodeWriter writer, ulong rip, [NotNullWhen(false)] out string? errorMessage, out AssemblerResult assemblerResult, BlockEncoderOptions options = BlockEncoderOptions.None)
		{
			if (writer == null)
			{
				ThrowHelper.ThrowArgumentNullException_writer();
			}
			assemblerResult = default(AssemblerResult);
			if (prefixFlags != 0)
			{
				errorMessage = $"Unused prefixes {prefixFlags}. You must emit an instruction after using an instruction prefix.";
				return false;
			}
			if (!currentLabel.IsEmpty)
			{
				errorMessage = $"Unused label {currentLabel}. You must emit an instruction after emitting a label.";
				return false;
			}
			if (definedAnonLabel)
			{
				errorMessage = "Unused anonymous label. You must emit an instruction after emitting a label.";
				return false;
			}
			if (!nextAnonLabel.IsEmpty)
			{
				errorMessage = "Found an @F anonymous label reference but there was no call to AnonymousLabel";
				return false;
			}
			InstructionBlock[] blocks = new InstructionBlock[1]
			{
				new InstructionBlock(writer, instructions, rip)
			};
			if (BlockEncoder.TryEncode(Bitness, blocks, out errorMessage, out BlockEncoderResult[] result, options))
			{
				assemblerResult = new AssemblerResult(result);
				return true;
			}
			assemblerResult = new AssemblerResult(Array2.Empty<BlockEncoderResult>());
			return false;
		}

		private InvalidOperationException NoOpCodeFoundFor(Mnemonic mnemonic, params object[] argNames)
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("Unable to calculate an OpCode for `" + mnemonic.ToString().ToLowerInvariant());
			for (int i = 0; i < argNames.Length; i++)
			{
				stringBuilder.Append((i == 0) ? " " : ", ");
				stringBuilder.Append(argNames[i]);
			}
			stringBuilder.Append($"`. Combination of arguments and/or current bitness {Bitness} is not compatible with any existing OpCode encoding.");
			return new InvalidOperationException(stringBuilder.ToString());
		}

		public void aaa()
		{
			AddInstruction(Instruction.Create(Code.Aaa));
		}

		public void aad(sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Aad_imm8, imm));
		}

		public void aad(byte imm)
		{
			AddInstruction(Instruction.Create(Code.Aad_imm8, (uint)imm));
		}

		public void aam(sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Aam_imm8, imm));
		}

		public void aam(byte imm)
		{
			AddInstruction(Instruction.Create(Code.Aam_imm8, (uint)imm));
		}

		public void aas()
		{
			AddInstruction(Instruction.Create(Code.Aas));
		}

		public void adc(AssemblerRegister8 dst, AssemblerRegister8 src)
		{
			AddInstruction(Instruction.Create(Code.Adc_rm8_r8, dst, src));
		}

		public void adc(AssemblerMemoryOperand dst, AssemblerRegister8 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_rm8_r8, in memory, src));
		}

		public void adc(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Adc_rm16_r16, dst, src));
		}

		public void adc(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_rm16_r16, in memory, src));
		}

		public void adc(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Adc_rm32_r32, dst, src));
		}

		public void adc(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_rm32_r32, in memory, src));
		}

		public void adc(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Adc_rm64_r64, dst, src));
		}

		public void adc(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_rm64_r64, in memory, src));
		}

		public void adc(AssemblerRegister8 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_r8_rm8, register, in memory));
		}

		public void adc(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_r16_rm16, register, in memory));
		}

		public void adc(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_r32_rm32, register, in memory));
		}

		public void adc(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adc_r64_rm64, register, in memory));
		}

		public void adc(AssemblerRegister8 dst, sbyte imm)
		{
			Code code = (((Register)dst == Register.AL) ? Code.Adc_AL_imm8 : Code.Adc_rm8_imm8);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void adc(AssemblerRegister16 dst, short imm)
		{
			Code code = (((Register)dst != Register.AX) ? ((imm >= -128 && imm <= 127) ? Code.Adc_rm16_imm8 : Code.Adc_rm16_imm16) : Code.Adc_AX_imm16);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void adc(AssemblerRegister32 dst, int imm)
		{
			Code code = (((Register)dst != Register.EAX) ? ((imm >= -128 && imm <= 127) ? Code.Adc_rm32_imm8 : Code.Adc_rm32_imm32) : Code.Adc_EAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void adc(AssemblerRegister64 dst, int imm)
		{
			Code code = (((Register)dst != Register.RAX) ? ((imm >= -128 && imm <= 127) ? Code.Adc_rm64_imm8 : Code.Adc_rm64_imm32) : Code.Adc_RAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void adc(AssemblerMemoryOperand dst, int imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.Adc_rm64_imm8 : Code.Adc_rm64_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.Adc_rm32_imm8 : Code.Adc_rm32_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Word)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.Adc_rm16_imm8 : Code.Adc_rm16_imm16);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Byte)
				{
					throw NoOpCodeFoundFor(Mnemonic.Adc, dst, imm);
				}
				code = Code.Adc_rm8_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void adc(AssemblerRegister8 dst, byte imm)
		{
			Code code = (((Register)dst == Register.AL) ? Code.Adc_AL_imm8 : Code.Adc_rm8_imm8);
			AddInstruction(Instruction.Create(code, (Register)dst, (uint)imm));
		}

		public void adc(AssemblerRegister16 dst, ushort imm)
		{
			Code code = (((Register)dst != Register.AX) ? ((imm <= 127 || (65408 <= imm && imm <= ushort.MaxValue)) ? Code.Adc_rm16_imm8 : Code.Adc_rm16_imm16) : Code.Adc_AX_imm16);
			AddInstruction(Instruction.Create(code, (Register)dst, (uint)imm));
		}

		public void adc(AssemblerRegister32 dst, uint imm)
		{
			Code code = (((Register)dst != Register.EAX) ? ((imm <= 127 || 4294967168u <= imm) ? Code.Adc_rm32_imm8 : Code.Adc_rm32_imm32) : Code.Adc_EAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void adc(AssemblerMemoryOperand dst, uint imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((imm <= 127 || 4294967168u <= imm) ? Code.Adc_rm32_imm8 : Code.Adc_rm32_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Word)
			{
				code = ((imm <= 127 || (65408 <= imm && imm <= 65535)) ? Code.Adc_rm16_imm8 : Code.Adc_rm16_imm16);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Byte)
				{
					throw NoOpCodeFoundFor(Mnemonic.Adc, dst, imm);
				}
				code = Code.Adc_rm8_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void adcx(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Adcx_r32_rm32, dst, src));
		}

		public void adcx(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Adcx_r64_rm64, dst, src));
		}

		public void adcx(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adcx_r32_rm32, register, in memory));
		}

		public void adcx(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adcx_r64_rm64, register, in memory));
		}

		public void add(AssemblerRegister8 dst, AssemblerRegister8 src)
		{
			AddInstruction(Instruction.Create(Code.Add_rm8_r8, dst, src));
		}

		public void add(AssemblerMemoryOperand dst, AssemblerRegister8 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_rm8_r8, in memory, src));
		}

		public void add(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Add_rm16_r16, dst, src));
		}

		public void add(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_rm16_r16, in memory, src));
		}

		public void add(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Add_rm32_r32, dst, src));
		}

		public void add(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_rm32_r32, in memory, src));
		}

		public void add(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Add_rm64_r64, dst, src));
		}

		public void add(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_rm64_r64, in memory, src));
		}

		public void add(AssemblerRegister8 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_r8_rm8, register, in memory));
		}

		public void add(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_r16_rm16, register, in memory));
		}

		public void add(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_r32_rm32, register, in memory));
		}

		public void add(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Add_r64_rm64, register, in memory));
		}

		public void add(AssemblerRegister8 dst, sbyte imm)
		{
			Code code = (((Register)dst == Register.AL) ? Code.Add_AL_imm8 : Code.Add_rm8_imm8);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void add(AssemblerRegister16 dst, short imm)
		{
			Code code = (((Register)dst != Register.AX) ? ((imm >= -128 && imm <= 127) ? Code.Add_rm16_imm8 : Code.Add_rm16_imm16) : Code.Add_AX_imm16);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void add(AssemblerRegister32 dst, int imm)
		{
			Code code = (((Register)dst != Register.EAX) ? ((imm >= -128 && imm <= 127) ? Code.Add_rm32_imm8 : Code.Add_rm32_imm32) : Code.Add_EAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void add(AssemblerRegister64 dst, int imm)
		{
			Code code = (((Register)dst != Register.RAX) ? ((imm >= -128 && imm <= 127) ? Code.Add_rm64_imm8 : Code.Add_rm64_imm32) : Code.Add_RAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void add(AssemblerMemoryOperand dst, int imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.Add_rm64_imm8 : Code.Add_rm64_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.Add_rm32_imm8 : Code.Add_rm32_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Word)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.Add_rm16_imm8 : Code.Add_rm16_imm16);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Byte)
				{
					throw NoOpCodeFoundFor(Mnemonic.Add, dst, imm);
				}
				code = Code.Add_rm8_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void add(AssemblerRegister8 dst, byte imm)
		{
			Code code = (((Register)dst == Register.AL) ? Code.Add_AL_imm8 : Code.Add_rm8_imm8);
			AddInstruction(Instruction.Create(code, (Register)dst, (uint)imm));
		}

		public void add(AssemblerRegister16 dst, ushort imm)
		{
			Code code = (((Register)dst != Register.AX) ? ((imm <= 127 || (65408 <= imm && imm <= ushort.MaxValue)) ? Code.Add_rm16_imm8 : Code.Add_rm16_imm16) : Code.Add_AX_imm16);
			AddInstruction(Instruction.Create(code, (Register)dst, (uint)imm));
		}

		public void add(AssemblerRegister32 dst, uint imm)
		{
			Code code = (((Register)dst != Register.EAX) ? ((imm <= 127 || 4294967168u <= imm) ? Code.Add_rm32_imm8 : Code.Add_rm32_imm32) : Code.Add_EAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void add(AssemblerMemoryOperand dst, uint imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((imm <= 127 || 4294967168u <= imm) ? Code.Add_rm32_imm8 : Code.Add_rm32_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Word)
			{
				code = ((imm <= 127 || (65408 <= imm && imm <= 65535)) ? Code.Add_rm16_imm8 : Code.Add_rm16_imm16);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Byte)
				{
					throw NoOpCodeFoundFor(Mnemonic.Add, dst, imm);
				}
				code = Code.Add_rm8_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void addpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Addpd_xmm_xmmm128, dst, src));
		}

		public void addpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Addpd_xmm_xmmm128, register, in memory));
		}

		public void addps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Addps_xmm_xmmm128, dst, src));
		}

		public void addps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Addps_xmm_xmmm128, register, in memory));
		}

		public void addsd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Addsd_xmm_xmmm64, dst, src));
		}

		public void addsd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Addsd_xmm_xmmm64, register, in memory));
		}

		public void addss(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Addss_xmm_xmmm32, dst, src));
		}

		public void addss(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Addss_xmm_xmmm32, register, in memory));
		}

		public void addsubpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Addsubpd_xmm_xmmm128, dst, src));
		}

		public void addsubpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Addsubpd_xmm_xmmm128, register, in memory));
		}

		public void addsubps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Addsubps_xmm_xmmm128, dst, src));
		}

		public void addsubps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Addsubps_xmm_xmmm128, register, in memory));
		}

		public void adox(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Adox_r32_rm32, dst, src));
		}

		public void adox(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Adox_r64_rm64, dst, src));
		}

		public void adox(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adox_r32_rm32, register, in memory));
		}

		public void adox(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Adox_r64_rm64, register, in memory));
		}

		public void aesdec(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Aesdec_xmm_xmmm128, dst, src));
		}

		public void aesdec(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesdec_xmm_xmmm128, register, in memory));
		}

		public void aesdec128kl(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesdec128kl_xmm_m384, register, in memory));
		}

		public void aesdec256kl(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesdec256kl_xmm_m512, register, in memory));
		}

		public void aesdeclast(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Aesdeclast_xmm_xmmm128, dst, src));
		}

		public void aesdeclast(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesdeclast_xmm_xmmm128, register, in memory));
		}

		public void aesdecwide128kl(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesdecwide128kl_m384, in memory));
		}

		public void aesdecwide256kl(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesdecwide256kl_m512, in memory));
		}

		public void aesenc(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Aesenc_xmm_xmmm128, dst, src));
		}

		public void aesenc(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesenc_xmm_xmmm128, register, in memory));
		}

		public void aesenc128kl(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesenc128kl_xmm_m384, register, in memory));
		}

		public void aesenc256kl(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesenc256kl_xmm_m512, register, in memory));
		}

		public void aesenclast(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Aesenclast_xmm_xmmm128, dst, src));
		}

		public void aesenclast(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesenclast_xmm_xmmm128, register, in memory));
		}

		public void aesencwide128kl(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesencwide128kl_m384, in memory));
		}

		public void aesencwide256kl(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesencwide256kl_m512, in memory));
		}

		public void aesimc(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Aesimc_xmm_xmmm128, dst, src));
		}

		public void aesimc(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aesimc_xmm_xmmm128, register, in memory));
		}

		public void aeskeygenassist(AssemblerRegisterXMM dst, AssemblerRegisterXMM src1, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Aeskeygenassist_xmm_xmmm128_imm8, dst, src1, imm));
		}

		public void aeskeygenassist(AssemblerRegisterXMM dst, AssemblerMemoryOperand src1, sbyte imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aeskeygenassist_xmm_xmmm128_imm8, register, in memory, imm));
		}

		public void aeskeygenassist(AssemblerRegisterXMM dst, AssemblerRegisterXMM src1, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Aeskeygenassist_xmm_xmmm128_imm8, (Register)dst, (Register)src1, (uint)imm));
		}

		public void aeskeygenassist(AssemblerRegisterXMM dst, AssemblerMemoryOperand src1, byte imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Aeskeygenassist_xmm_xmmm128_imm8, register, in memory, (uint)imm));
		}

		public void altinst()
		{
			AddInstruction(Instruction.Create(Code.Altinst));
		}

		public void and(AssemblerRegister8 dst, AssemblerRegister8 src)
		{
			AddInstruction(Instruction.Create(Code.And_rm8_r8, dst, src));
		}

		public void and(AssemblerMemoryOperand dst, AssemblerRegister8 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_rm8_r8, in memory, src));
		}

		public void and(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.And_rm16_r16, dst, src));
		}

		public void and(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_rm16_r16, in memory, src));
		}

		public void and(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.And_rm32_r32, dst, src));
		}

		public void and(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_rm32_r32, in memory, src));
		}

		public void and(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.And_rm64_r64, dst, src));
		}

		public void and(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_rm64_r64, in memory, src));
		}

		public void and(AssemblerRegister8 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_r8_rm8, register, in memory));
		}

		public void and(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_r16_rm16, register, in memory));
		}

		public void and(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_r32_rm32, register, in memory));
		}

		public void and(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.And_r64_rm64, register, in memory));
		}

		public void and(AssemblerRegister8 dst, sbyte imm)
		{
			Code code = (((Register)dst == Register.AL) ? Code.And_AL_imm8 : Code.And_rm8_imm8);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void and(AssemblerRegister16 dst, short imm)
		{
			Code code = (((Register)dst != Register.AX) ? ((imm >= -128 && imm <= 127) ? Code.And_rm16_imm8 : Code.And_rm16_imm16) : Code.And_AX_imm16);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void and(AssemblerRegister32 dst, int imm)
		{
			Code code = (((Register)dst != Register.EAX) ? ((imm >= -128 && imm <= 127) ? Code.And_rm32_imm8 : Code.And_rm32_imm32) : Code.And_EAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void and(AssemblerRegister64 dst, int imm)
		{
			Code code = (((Register)dst != Register.RAX) ? ((imm >= -128 && imm <= 127) ? Code.And_rm64_imm8 : Code.And_rm64_imm32) : Code.And_RAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void and(AssemblerMemoryOperand dst, int imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.And_rm64_imm8 : Code.And_rm64_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.And_rm32_imm8 : Code.And_rm32_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Word)
			{
				code = ((imm >= -128 && imm <= 127) ? Code.And_rm16_imm8 : Code.And_rm16_imm16);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Byte)
				{
					throw NoOpCodeFoundFor(Mnemonic.And, dst, imm);
				}
				code = Code.And_rm8_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void and(AssemblerRegister8 dst, byte imm)
		{
			Code code = (((Register)dst == Register.AL) ? Code.And_AL_imm8 : Code.And_rm8_imm8);
			AddInstruction(Instruction.Create(code, (Register)dst, (uint)imm));
		}

		public void and(AssemblerRegister16 dst, ushort imm)
		{
			Code code = (((Register)dst != Register.AX) ? ((imm <= 127 || (65408 <= imm && imm <= ushort.MaxValue)) ? Code.And_rm16_imm8 : Code.And_rm16_imm16) : Code.And_AX_imm16);
			AddInstruction(Instruction.Create(code, (Register)dst, (uint)imm));
		}

		public void and(AssemblerRegister32 dst, uint imm)
		{
			Code code = (((Register)dst != Register.EAX) ? ((imm <= 127 || 4294967168u <= imm) ? Code.And_rm32_imm8 : Code.And_rm32_imm32) : Code.And_EAX_imm32);
			AddInstruction(Instruction.Create(code, dst, imm));
		}

		public void and(AssemblerMemoryOperand dst, uint imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((imm <= 127 || 4294967168u <= imm) ? Code.And_rm32_imm8 : Code.And_rm32_imm32);
			}
			else if (dst.Size == MemoryOperandSize.Word)
			{
				code = ((imm <= 127 || (65408 <= imm && imm <= 65535)) ? Code.And_rm16_imm8 : Code.And_rm16_imm16);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Byte)
				{
					throw NoOpCodeFoundFor(Mnemonic.And, dst, imm);
				}
				code = Code.And_rm8_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void andn(AssemblerRegister32 dst, AssemblerRegister32 src1, AssemblerRegister32 src2)
		{
			AddInstruction(Instruction.Create(Code.VEX_Andn_r32_r32_rm32, dst, src1, src2));
		}

		public void andn(AssemblerRegister64 dst, AssemblerRegister64 src1, AssemblerRegister64 src2)
		{
			AddInstruction(Instruction.Create(Code.VEX_Andn_r64_r64_rm64, dst, src1, src2));
		}

		public void andn(AssemblerRegister32 dst, AssemblerRegister32 src1, AssemblerMemoryOperand src2)
		{
			Register register = dst;
			Register register2 = src1;
			MemoryOperand memory = src2.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Andn_r32_r32_rm32, register, register2, in memory));
		}

		public void andn(AssemblerRegister64 dst, AssemblerRegister64 src1, AssemblerMemoryOperand src2)
		{
			Register register = dst;
			Register register2 = src1;
			MemoryOperand memory = src2.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Andn_r64_r64_rm64, register, register2, in memory));
		}

		public void andnpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Andnpd_xmm_xmmm128, dst, src));
		}

		public void andnpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Andnpd_xmm_xmmm128, register, in memory));
		}

		public void andnps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Andnps_xmm_xmmm128, dst, src));
		}

		public void andnps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Andnps_xmm_xmmm128, register, in memory));
		}

		public void andpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Andpd_xmm_xmmm128, dst, src));
		}

		public void andpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Andpd_xmm_xmmm128, register, in memory));
		}

		public void andps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Andps_xmm_xmmm128, dst, src));
		}

		public void andps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Andps_xmm_xmmm128, register, in memory));
		}

		public void arpl(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Arpl_rm16_r16, dst, src));
		}

		public void arpl(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Arpl_rm16_r16, in memory, src));
		}

		public void arpl(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Arpl_r32m16_r32, dst, src));
		}

		public void arpl(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Arpl_r32m16_r32, in memory, src));
		}

		public void bb0_reset()
		{
			AddInstruction(Instruction.Create(Code.Bb0_reset));
		}

		public void bb1_reset()
		{
			AddInstruction(Instruction.Create(Code.Bb1_reset));
		}

		public void bextr(AssemblerRegister32 dst, AssemblerRegister32 src1, AssemblerRegister32 src2)
		{
			AddInstruction(Instruction.Create(Code.VEX_Bextr_r32_rm32_r32, dst, src1, src2));
		}

		public void bextr(AssemblerRegister32 dst, AssemblerMemoryOperand src1, AssemblerRegister32 src2)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Bextr_r32_rm32_r32, register, in memory, src2));
		}

		public void bextr(AssemblerRegister64 dst, AssemblerRegister64 src1, AssemblerRegister64 src2)
		{
			AddInstruction(Instruction.Create(Code.VEX_Bextr_r64_rm64_r64, dst, src1, src2));
		}

		public void bextr(AssemblerRegister64 dst, AssemblerMemoryOperand src1, AssemblerRegister64 src2)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Bextr_r64_rm64_r64, register, in memory, src2));
		}

		public void bextr(AssemblerRegister32 dst, AssemblerRegister32 src1, int imm)
		{
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r32_rm32_imm32, dst, src1, imm));
		}

		public void bextr(AssemblerRegister64 dst, AssemblerRegister64 src1, int imm)
		{
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r64_rm64_imm32, dst, src1, imm));
		}

		public void bextr(AssemblerRegister32 dst, AssemblerMemoryOperand src1, int imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r32_rm32_imm32, register, in memory, imm));
		}

		public void bextr(AssemblerRegister64 dst, AssemblerMemoryOperand src1, int imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r64_rm64_imm32, register, in memory, imm));
		}

		public void bextr(AssemblerRegister32 dst, AssemblerRegister32 src1, uint imm)
		{
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r32_rm32_imm32, dst, src1, imm));
		}

		public void bextr(AssemblerRegister64 dst, AssemblerRegister64 src1, uint imm)
		{
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r64_rm64_imm32, dst, src1, imm));
		}

		public void bextr(AssemblerRegister32 dst, AssemblerMemoryOperand src1, uint imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r32_rm32_imm32, register, in memory, imm));
		}

		public void bextr(AssemblerRegister64 dst, AssemblerMemoryOperand src1, uint imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Bextr_r64_rm64_imm32, register, in memory, imm));
		}

		public void blcfill(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcfill_r32_rm32, dst, src));
		}

		public void blcfill(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcfill_r64_rm64, dst, src));
		}

		public void blcfill(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcfill_r32_rm32, register, in memory));
		}

		public void blcfill(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcfill_r64_rm64, register, in memory));
		}

		public void blci(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blci_r32_rm32, dst, src));
		}

		public void blci(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blci_r64_rm64, dst, src));
		}

		public void blci(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blci_r32_rm32, register, in memory));
		}

		public void blci(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blci_r64_rm64, register, in memory));
		}

		public void blcic(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcic_r32_rm32, dst, src));
		}

		public void blcic(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcic_r64_rm64, dst, src));
		}

		public void blcic(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcic_r32_rm32, register, in memory));
		}

		public void blcic(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcic_r64_rm64, register, in memory));
		}

		public void blcmsk(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcmsk_r32_rm32, dst, src));
		}

		public void blcmsk(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcmsk_r64_rm64, dst, src));
		}

		public void blcmsk(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcmsk_r32_rm32, register, in memory));
		}

		public void blcmsk(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcmsk_r64_rm64, register, in memory));
		}

		public void blcs(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcs_r32_rm32, dst, src));
		}

		public void blcs(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blcs_r64_rm64, dst, src));
		}

		public void blcs(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcs_r32_rm32, register, in memory));
		}

		public void blcs(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blcs_r64_rm64, register, in memory));
		}

		public void blendpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src1, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Blendpd_xmm_xmmm128_imm8, dst, src1, imm));
		}

		public void blendpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src1, sbyte imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Blendpd_xmm_xmmm128_imm8, register, in memory, imm));
		}

		public void blendpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src1, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Blendpd_xmm_xmmm128_imm8, (Register)dst, (Register)src1, (uint)imm));
		}

		public void blendpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src1, byte imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Blendpd_xmm_xmmm128_imm8, register, in memory, (uint)imm));
		}

		public void blendps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src1, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Blendps_xmm_xmmm128_imm8, dst, src1, imm));
		}

		public void blendps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src1, sbyte imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Blendps_xmm_xmmm128_imm8, register, in memory, imm));
		}

		public void blendps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src1, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Blendps_xmm_xmmm128_imm8, (Register)dst, (Register)src1, (uint)imm));
		}

		public void blendps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src1, byte imm)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Blendps_xmm_xmmm128_imm8, register, in memory, (uint)imm));
		}

		public void blendvpd(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Blendvpd_xmm_xmmm128, dst, src));
		}

		public void blendvpd(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Blendvpd_xmm_xmmm128, register, in memory));
		}

		public void blendvps(AssemblerRegisterXMM dst, AssemblerRegisterXMM src)
		{
			AddInstruction(Instruction.Create(Code.Blendvps_xmm_xmmm128, dst, src));
		}

		public void blendvps(AssemblerRegisterXMM dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Blendvps_xmm_xmmm128, register, in memory));
		}

		public void blsfill(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blsfill_r32_rm32, dst, src));
		}

		public void blsfill(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blsfill_r64_rm64, dst, src));
		}

		public void blsfill(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blsfill_r32_rm32, register, in memory));
		}

		public void blsfill(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blsfill_r64_rm64, register, in memory));
		}

		public void blsi(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.VEX_Blsi_r32_rm32, dst, src));
		}

		public void blsi(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.VEX_Blsi_r64_rm64, dst, src));
		}

		public void blsi(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Blsi_r32_rm32, register, in memory));
		}

		public void blsi(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Blsi_r64_rm64, register, in memory));
		}

		public void blsic(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blsic_r32_rm32, dst, src));
		}

		public void blsic(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.XOP_Blsic_r64_rm64, dst, src));
		}

		public void blsic(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blsic_r32_rm32, register, in memory));
		}

		public void blsic(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.XOP_Blsic_r64_rm64, register, in memory));
		}

		public void blsmsk(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.VEX_Blsmsk_r32_rm32, dst, src));
		}

		public void blsmsk(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.VEX_Blsmsk_r64_rm64, dst, src));
		}

		public void blsmsk(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Blsmsk_r32_rm32, register, in memory));
		}

		public void blsmsk(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Blsmsk_r64_rm64, register, in memory));
		}

		public void blsr(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.VEX_Blsr_r32_rm32, dst, src));
		}

		public void blsr(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.VEX_Blsr_r64_rm64, dst, src));
		}

		public void blsr(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Blsr_r32_rm32, register, in memory));
		}

		public void blsr(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Blsr_r64_rm64, register, in memory));
		}

		public void bndcl(AssemblerRegisterBND dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bndcl_bnd_rm32, dst, src));
		}

		public void bndcl(AssemblerRegisterBND dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bndcl_bnd_rm64, dst, src));
		}

		public void bndcl(AssemblerRegisterBND dst, AssemblerMemoryOperand src)
		{
			Code code;
			if (src.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bndcl_bnd_rm64;
			}
			else
			{
				if (src.Size != MemoryOperandSize.Dword)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bndcl, dst, src);
				}
				code = Code.Bndcl_bnd_rm32;
			}
			Code code2 = code;
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, register, in memory));
		}

		public void bndcn(AssemblerRegisterBND dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bndcn_bnd_rm32, dst, src));
		}

		public void bndcn(AssemblerRegisterBND dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bndcn_bnd_rm64, dst, src));
		}

		public void bndcn(AssemblerRegisterBND dst, AssemblerMemoryOperand src)
		{
			Code code;
			if (src.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bndcn_bnd_rm64;
			}
			else
			{
				if (src.Size != MemoryOperandSize.Dword)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bndcn, dst, src);
				}
				code = Code.Bndcn_bnd_rm32;
			}
			Code code2 = code;
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, register, in memory));
		}

		public void bndcu(AssemblerRegisterBND dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bndcu_bnd_rm32, dst, src));
		}

		public void bndcu(AssemblerRegisterBND dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bndcu_bnd_rm64, dst, src));
		}

		public void bndcu(AssemblerRegisterBND dst, AssemblerMemoryOperand src)
		{
			Code code;
			if (src.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bndcu_bnd_rm64;
			}
			else
			{
				if (src.Size != MemoryOperandSize.Dword)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bndcu, dst, src);
				}
				code = Code.Bndcu_bnd_rm32;
			}
			Code code2 = code;
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, register, in memory));
		}

		public void bndldx(AssemblerRegisterBND dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bndldx_bnd_mib, register, in memory));
		}

		public void bndmk(AssemblerRegisterBND dst, AssemblerMemoryOperand src)
		{
			Code code;
			if (src.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bndmk_bnd_m64;
			}
			else
			{
				if (src.Size != MemoryOperandSize.Dword)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bndmk, dst, src);
				}
				code = Code.Bndmk_bnd_m32;
			}
			Code code2 = code;
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, register, in memory));
		}

		public void bndmov(AssemblerRegisterBND dst, AssemblerRegisterBND src)
		{
			Code code = ((Bitness == 64) ? Code.Bndmov_bnd_bndm128 : Code.Bndmov_bnd_bndm64);
			AddInstruction(Instruction.Create(code, dst, src));
		}

		public void bndmov(AssemblerMemoryOperand dst, AssemblerRegisterBND src)
		{
			Code code = ((Bitness == 64) ? Code.Bndmov_bndm128_bnd : Code.Bndmov_bndm64_bnd);
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code, in memory, src));
		}

		public void bndmov(AssemblerRegisterBND dst, AssemblerMemoryOperand src)
		{
			Code code = ((Bitness == 64) ? Code.Bndmov_bnd_bndm128 : Code.Bndmov_bnd_bndm64);
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code, register, in memory));
		}

		public void bndstx(AssemblerMemoryOperand dst, AssemblerRegisterBND src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bndstx_mib_bnd, in memory, src));
		}

		public void bound(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bound_r16_m1616, register, in memory));
		}

		public void bound(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bound_r32_m3232, register, in memory));
		}

		public void bsf(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Bsf_r16_rm16, dst, src));
		}

		public void bsf(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bsf_r32_rm32, dst, src));
		}

		public void bsf(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bsf_r64_rm64, dst, src));
		}

		public void bsf(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bsf_r16_rm16, register, in memory));
		}

		public void bsf(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bsf_r32_rm32, register, in memory));
		}

		public void bsf(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bsf_r64_rm64, register, in memory));
		}

		public void bsr(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Bsr_r16_rm16, dst, src));
		}

		public void bsr(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bsr_r32_rm32, dst, src));
		}

		public void bsr(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bsr_r64_rm64, dst, src));
		}

		public void bsr(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bsr_r16_rm16, register, in memory));
		}

		public void bsr(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bsr_r32_rm32, register, in memory));
		}

		public void bsr(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bsr_r64_rm64, register, in memory));
		}

		public void bswap(AssemblerRegister16 dst)
		{
			AddInstruction(Instruction.Create(Code.Bswap_r16, dst));
		}

		public void bswap(AssemblerRegister32 dst)
		{
			AddInstruction(Instruction.Create(Code.Bswap_r32, dst));
		}

		public void bswap(AssemblerRegister64 dst)
		{
			AddInstruction(Instruction.Create(Code.Bswap_r64, dst));
		}

		public void bt(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm16_r16, dst, src));
		}

		public void bt(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bt_rm16_r16, in memory, src));
		}

		public void bt(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm32_r32, dst, src));
		}

		public void bt(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bt_rm32_r32, in memory, src));
		}

		public void bt(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm64_r64, dst, src));
		}

		public void bt(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bt_rm64_r64, in memory, src));
		}

		public void bt(AssemblerRegister16 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm16_imm8, dst, imm));
		}

		public void bt(AssemblerRegister32 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm32_imm8, dst, imm));
		}

		public void bt(AssemblerRegister64 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm64_imm8, dst, imm));
		}

		public void bt(AssemblerMemoryOperand dst, sbyte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bt_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Bt_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bt, dst, imm);
				}
				code = Code.Bt_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void bt(AssemblerRegister16 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm16_imm8, (Register)dst, (uint)imm));
		}

		public void bt(AssemblerRegister32 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm32_imm8, (Register)dst, (uint)imm));
		}

		public void bt(AssemblerRegister64 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Bt_rm64_imm8, (Register)dst, (uint)imm));
		}

		public void bt(AssemblerMemoryOperand dst, byte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bt_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Bt_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bt, dst, imm);
				}
				code = Code.Bt_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, (uint)imm));
		}

		public void btc(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm16_r16, dst, src));
		}

		public void btc(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Btc_rm16_r16, in memory, src));
		}

		public void btc(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm32_r32, dst, src));
		}

		public void btc(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Btc_rm32_r32, in memory, src));
		}

		public void btc(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm64_r64, dst, src));
		}

		public void btc(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Btc_rm64_r64, in memory, src));
		}

		public void btc(AssemblerRegister16 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm16_imm8, dst, imm));
		}

		public void btc(AssemblerRegister32 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm32_imm8, dst, imm));
		}

		public void btc(AssemblerRegister64 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm64_imm8, dst, imm));
		}

		public void btc(AssemblerMemoryOperand dst, sbyte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Btc_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Btc_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Btc, dst, imm);
				}
				code = Code.Btc_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void btc(AssemblerRegister16 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm16_imm8, (Register)dst, (uint)imm));
		}

		public void btc(AssemblerRegister32 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm32_imm8, (Register)dst, (uint)imm));
		}

		public void btc(AssemblerRegister64 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Btc_rm64_imm8, (Register)dst, (uint)imm));
		}

		public void btc(AssemblerMemoryOperand dst, byte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Btc_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Btc_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Btc, dst, imm);
				}
				code = Code.Btc_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, (uint)imm));
		}

		public void btr(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm16_r16, dst, src));
		}

		public void btr(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Btr_rm16_r16, in memory, src));
		}

		public void btr(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm32_r32, dst, src));
		}

		public void btr(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Btr_rm32_r32, in memory, src));
		}

		public void btr(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm64_r64, dst, src));
		}

		public void btr(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Btr_rm64_r64, in memory, src));
		}

		public void btr(AssemblerRegister16 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm16_imm8, dst, imm));
		}

		public void btr(AssemblerRegister32 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm32_imm8, dst, imm));
		}

		public void btr(AssemblerRegister64 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm64_imm8, dst, imm));
		}

		public void btr(AssemblerMemoryOperand dst, sbyte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Btr_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Btr_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Btr, dst, imm);
				}
				code = Code.Btr_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void btr(AssemblerRegister16 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm16_imm8, (Register)dst, (uint)imm));
		}

		public void btr(AssemblerRegister32 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm32_imm8, (Register)dst, (uint)imm));
		}

		public void btr(AssemblerRegister64 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Btr_rm64_imm8, (Register)dst, (uint)imm));
		}

		public void btr(AssemblerMemoryOperand dst, byte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Btr_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Btr_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Btr, dst, imm);
				}
				code = Code.Btr_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, (uint)imm));
		}

		public void bts(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm16_r16, dst, src));
		}

		public void bts(AssemblerMemoryOperand dst, AssemblerRegister16 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bts_rm16_r16, in memory, src));
		}

		public void bts(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm32_r32, dst, src));
		}

		public void bts(AssemblerMemoryOperand dst, AssemblerRegister32 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bts_rm32_r32, in memory, src));
		}

		public void bts(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm64_r64, dst, src));
		}

		public void bts(AssemblerMemoryOperand dst, AssemblerRegister64 src)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Bts_rm64_r64, in memory, src));
		}

		public void bts(AssemblerRegister16 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm16_imm8, dst, imm));
		}

		public void bts(AssemblerRegister32 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm32_imm8, dst, imm));
		}

		public void bts(AssemblerRegister64 dst, sbyte imm)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm64_imm8, dst, imm));
		}

		public void bts(AssemblerMemoryOperand dst, sbyte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bts_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Bts_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bts, dst, imm);
				}
				code = Code.Bts_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, imm));
		}

		public void bts(AssemblerRegister16 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm16_imm8, (Register)dst, (uint)imm));
		}

		public void bts(AssemblerRegister32 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm32_imm8, (Register)dst, (uint)imm));
		}

		public void bts(AssemblerRegister64 dst, byte imm)
		{
			AddInstruction(Instruction.Create(Code.Bts_rm64_imm8, (Register)dst, (uint)imm));
		}

		public void bts(AssemblerMemoryOperand dst, byte imm)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Bts_rm64_imm8;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = Code.Bts_rm32_imm8;
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Bts, dst, imm);
				}
				code = Code.Bts_rm16_imm8;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory, (uint)imm));
		}

		public void bzhi(AssemblerRegister32 dst, AssemblerRegister32 src1, AssemblerRegister32 src2)
		{
			AddInstruction(Instruction.Create(Code.VEX_Bzhi_r32_rm32_r32, dst, src1, src2));
		}

		public void bzhi(AssemblerRegister32 dst, AssemblerMemoryOperand src1, AssemblerRegister32 src2)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Bzhi_r32_rm32_r32, register, in memory, src2));
		}

		public void bzhi(AssemblerRegister64 dst, AssemblerRegister64 src1, AssemblerRegister64 src2)
		{
			AddInstruction(Instruction.Create(Code.VEX_Bzhi_r64_rm64_r64, dst, src1, src2));
		}

		public void bzhi(AssemblerRegister64 dst, AssemblerMemoryOperand src1, AssemblerRegister64 src2)
		{
			Register register = dst;
			MemoryOperand memory = src1.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.VEX_Bzhi_r64_rm64_r64, register, in memory, src2));
		}

		public void call(AssemblerRegister16 dst)
		{
			AddInstruction(Instruction.Create(Code.Call_rm16, dst));
		}

		public void call(AssemblerRegister32 dst)
		{
			AddInstruction(Instruction.Create(Code.Call_rm32, dst));
		}

		public void call(AssemblerRegister64 dst)
		{
			AddInstruction(Instruction.Create(Code.Call_rm64, dst));
		}

		public void call(AssemblerMemoryOperand dst)
		{
			Code code;
			if (dst.Size == MemoryOperandSize.Tbyte)
			{
				code = Code.Call_m1664;
			}
			else if (dst.Size == MemoryOperandSize.Qword)
			{
				code = Code.Call_rm64;
			}
			else if (dst.Size == MemoryOperandSize.Fword)
			{
				code = Code.Call_m1632;
			}
			else if (dst.Size == MemoryOperandSize.Dword)
			{
				code = ((Bitness >= 32) ? Code.Call_rm32 : Code.Call_m1616);
			}
			else
			{
				if (dst.Size != MemoryOperandSize.Word)
				{
					throw NoOpCodeFoundFor(Mnemonic.Call, dst);
				}
				code = Code.Call_rm16;
			}
			Code code2 = code;
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(code2, in memory));
		}

		public void call(Label dst)
		{
			Code code = ((Bitness != 64) ? ((Bitness >= 32) ? Code.Call_rel32_32 : Code.Call_rel16) : Code.Call_rel32_64);
			AddInstruction(Instruction.CreateBranch(code, dst.Id));
		}

		public void call(ulong dst)
		{
			Code code = ((Bitness != 64) ? ((Bitness >= 32) ? Code.Call_rel32_32 : Code.Call_rel16) : Code.Call_rel32_64);
			AddInstruction(Instruction.CreateBranch(code, dst));
		}

		public void cbw()
		{
			AddInstruction(Instruction.Create(Code.Cbw));
		}

		public void ccs_encrypt()
		{
			Code code = ((Bitness != 64) ? ((Bitness >= 32) ? Code.Ccs_encrypt_32 : Code.Ccs_encrypt_16) : Code.Ccs_encrypt_64);
			AddInstruction(Instruction.Create(code));
		}

		public void ccs_hash()
		{
			Code code = ((Bitness != 64) ? ((Bitness >= 32) ? Code.Ccs_hash_32 : Code.Ccs_hash_16) : Code.Ccs_hash_64);
			AddInstruction(Instruction.Create(code));
		}

		public void cdq()
		{
			AddInstruction(Instruction.Create(Code.Cdq));
		}

		public void cdqe()
		{
			AddInstruction(Instruction.Create(Code.Cdqe));
		}

		public void cl1invmb()
		{
			AddInstruction(Instruction.Create(Code.Cl1invmb));
		}

		public void clac()
		{
			AddInstruction(Instruction.Create(Code.Clac));
		}

		public void clc()
		{
			AddInstruction(Instruction.Create(Code.Clc));
		}

		public void cld()
		{
			AddInstruction(Instruction.Create(Code.Cld));
		}

		public void cldemote(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cldemote_m8, in memory));
		}

		public void clflush(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Clflush_m8, in memory));
		}

		public void clflushopt(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Clflushopt_m8, in memory));
		}

		public void clgi()
		{
			AddInstruction(Instruction.Create(Code.Clgi));
		}

		public void cli()
		{
			AddInstruction(Instruction.Create(Code.Cli));
		}

		public void clrssbsy(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Clrssbsy_m64, in memory));
		}

		public void clts()
		{
			AddInstruction(Instruction.Create(Code.Clts));
		}

		public void clui()
		{
			AddInstruction(Instruction.Create(Code.Clui));
		}

		public void clwb(AssemblerMemoryOperand dst)
		{
			MemoryOperand memory = dst.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Clwb_m8, in memory));
		}

		public void clzero()
		{
			Code code = ((Bitness != 64) ? ((Bitness >= 32) ? Code.Clzerod : Code.Clzerow) : Code.Clzeroq);
			AddInstruction(Instruction.Create(code));
		}

		public void cmc()
		{
			AddInstruction(Instruction.Create(Code.Cmc));
		}

		public void cmova(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmova_r16_rm16, dst, src));
		}

		public void cmova(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmova_r32_rm32, dst, src));
		}

		public void cmova(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmova_r64_rm64, dst, src));
		}

		public void cmova(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmova_r16_rm16, register, in memory));
		}

		public void cmova(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmova_r32_rm32, register, in memory));
		}

		public void cmova(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmova_r64_rm64, register, in memory));
		}

		public void cmovae(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r16_rm16, dst, src));
		}

		public void cmovae(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r32_rm32, dst, src));
		}

		public void cmovae(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r64_rm64, dst, src));
		}

		public void cmovae(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r16_rm16, register, in memory));
		}

		public void cmovae(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r32_rm32, register, in memory));
		}

		public void cmovae(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r64_rm64, register, in memory));
		}

		public void cmovb(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r16_rm16, dst, src));
		}

		public void cmovb(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r32_rm32, dst, src));
		}

		public void cmovb(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r64_rm64, dst, src));
		}

		public void cmovb(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r16_rm16, register, in memory));
		}

		public void cmovb(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r32_rm32, register, in memory));
		}

		public void cmovb(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r64_rm64, register, in memory));
		}

		public void cmovbe(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovbe_r16_rm16, dst, src));
		}

		public void cmovbe(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovbe_r32_rm32, dst, src));
		}

		public void cmovbe(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovbe_r64_rm64, dst, src));
		}

		public void cmovbe(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovbe_r16_rm16, register, in memory));
		}

		public void cmovbe(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovbe_r32_rm32, register, in memory));
		}

		public void cmovbe(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovbe_r64_rm64, register, in memory));
		}

		public void cmovc(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r16_rm16, dst, src));
		}

		public void cmovc(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r32_rm32, dst, src));
		}

		public void cmovc(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r64_rm64, dst, src));
		}

		public void cmovc(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r16_rm16, register, in memory));
		}

		public void cmovc(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r32_rm32, register, in memory));
		}

		public void cmovc(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r64_rm64, register, in memory));
		}

		public void cmove(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmove_r16_rm16, dst, src));
		}

		public void cmove(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmove_r32_rm32, dst, src));
		}

		public void cmove(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmove_r64_rm64, dst, src));
		}

		public void cmove(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmove_r16_rm16, register, in memory));
		}

		public void cmove(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmove_r32_rm32, register, in memory));
		}

		public void cmove(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmove_r64_rm64, register, in memory));
		}

		public void cmovg(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovg_r16_rm16, dst, src));
		}

		public void cmovg(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovg_r32_rm32, dst, src));
		}

		public void cmovg(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovg_r64_rm64, dst, src));
		}

		public void cmovg(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovg_r16_rm16, register, in memory));
		}

		public void cmovg(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovg_r32_rm32, register, in memory));
		}

		public void cmovg(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovg_r64_rm64, register, in memory));
		}

		public void cmovge(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovge_r16_rm16, dst, src));
		}

		public void cmovge(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovge_r32_rm32, dst, src));
		}

		public void cmovge(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovge_r64_rm64, dst, src));
		}

		public void cmovge(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovge_r16_rm16, register, in memory));
		}

		public void cmovge(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovge_r32_rm32, register, in memory));
		}

		public void cmovge(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovge_r64_rm64, register, in memory));
		}

		public void cmovl(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovl_r16_rm16, dst, src));
		}

		public void cmovl(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovl_r32_rm32, dst, src));
		}

		public void cmovl(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovl_r64_rm64, dst, src));
		}

		public void cmovl(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovl_r16_rm16, register, in memory));
		}

		public void cmovl(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovl_r32_rm32, register, in memory));
		}

		public void cmovl(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovl_r64_rm64, register, in memory));
		}

		public void cmovle(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovle_r16_rm16, dst, src));
		}

		public void cmovle(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovle_r32_rm32, dst, src));
		}

		public void cmovle(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovle_r64_rm64, dst, src));
		}

		public void cmovle(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovle_r16_rm16, register, in memory));
		}

		public void cmovle(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovle_r32_rm32, register, in memory));
		}

		public void cmovle(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovle_r64_rm64, register, in memory));
		}

		public void cmovna(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovbe_r16_rm16, dst, src));
		}

		public void cmovna(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovbe_r32_rm32, dst, src));
		}

		public void cmovna(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovbe_r64_rm64, dst, src));
		}

		public void cmovna(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovbe_r16_rm16, register, in memory));
		}

		public void cmovna(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovbe_r32_rm32, register, in memory));
		}

		public void cmovna(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovbe_r64_rm64, register, in memory));
		}

		public void cmovnae(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r16_rm16, dst, src));
		}

		public void cmovnae(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r32_rm32, dst, src));
		}

		public void cmovnae(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovb_r64_rm64, dst, src));
		}

		public void cmovnae(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r16_rm16, register, in memory));
		}

		public void cmovnae(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r32_rm32, register, in memory));
		}

		public void cmovnae(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovb_r64_rm64, register, in memory));
		}

		public void cmovnb(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r16_rm16, dst, src));
		}

		public void cmovnb(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r32_rm32, dst, src));
		}

		public void cmovnb(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r64_rm64, dst, src));
		}

		public void cmovnb(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r16_rm16, register, in memory));
		}

		public void cmovnb(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r32_rm32, register, in memory));
		}

		public void cmovnb(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r64_rm64, register, in memory));
		}

		public void cmovnbe(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmova_r16_rm16, dst, src));
		}

		public void cmovnbe(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmova_r32_rm32, dst, src));
		}

		public void cmovnbe(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmova_r64_rm64, dst, src));
		}

		public void cmovnbe(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmova_r16_rm16, register, in memory));
		}

		public void cmovnbe(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmova_r32_rm32, register, in memory));
		}

		public void cmovnbe(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmova_r64_rm64, register, in memory));
		}

		public void cmovnc(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r16_rm16, dst, src));
		}

		public void cmovnc(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r32_rm32, dst, src));
		}

		public void cmovnc(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovae_r64_rm64, dst, src));
		}

		public void cmovnc(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r16_rm16, register, in memory));
		}

		public void cmovnc(AssemblerRegister32 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r32_rm32, register, in memory));
		}

		public void cmovnc(AssemblerRegister64 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovae_r64_rm64, register, in memory));
		}

		public void cmovne(AssemblerRegister16 dst, AssemblerRegister16 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovne_r16_rm16, dst, src));
		}

		public void cmovne(AssemblerRegister32 dst, AssemblerRegister32 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovne_r32_rm32, dst, src));
		}

		public void cmovne(AssemblerRegister64 dst, AssemblerRegister64 src)
		{
			AddInstruction(Instruction.Create(Code.Cmovne_r64_rm64, dst, src));
		}

		public void cmovne(AssemblerRegister16 dst, AssemblerMemoryOperand src)
		{
			Register register = dst;
			MemoryOperand memory = src.ToMemoryOperand(Bitness);
			AddInstruction(Instruction.Create(Code.Cmovne_r16_rm16, register, in memory));
		}

		public void cmovne(AssemblerRegister