/// <summary>
 /// Initializes a new instance of the <see cref="Neg"/> class.
 /// </summary>
 /// <param name="value">The value.</param>
 public Neg(EffectiveAddress value)
     : this((Operand)value)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(value != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Inc"/> class.
 /// </summary>
 /// <param name="subject">The subject memory operand.</param>
 public Inc(EffectiveAddress subject)
     : this((Operand)subject)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(subject != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Mul"/> class.
 /// </summary>
 /// <param name="multiplier">The multiplier.</param>
 public Mul(EffectiveAddress multiplier)
     : this((Operand)multiplier)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(multiplier != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="JmpFar"/> class.
 /// </summary>
 /// <param name="target">The memory location containing the new far jump target address and segment.</param>
 public JmpFar(EffectiveAddress target)
     : this((Operand)target)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(target != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Xadd"/> class.
 /// </summary>
 /// <param name="destination">The destination memory operand.</param>
 /// <param name="source">The source immediate register operand.</param>
 public Xadd(EffectiveAddress destination, RegisterOperand source)
     : this((Operand)destination, source)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(destination != null);
     Contract.Requires<ArgumentNullException>(source != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Movsxd"/> class.
 /// </summary>
 /// <param name="destination">The destination register.</param>
 /// <param name="source">The source memory operand.</param>
 public Movsxd(RegisterOperand destination, EffectiveAddress source)
     : this(destination, (Operand)source)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(destination != null);
     Contract.Requires<ArgumentNullException>(source != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Btc"/> class.
 /// </summary>
 /// <param name="subject">The memory operand whose bit is copied and toggled.</param>
 /// <param name="bitIndex">The index of the bit to copy.</param>
 public Btc(EffectiveAddress subject, RegisterOperand bitIndex)
     : this((Operand)subject, (Operand)bitIndex)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(subject != null);
     Contract.Requires<ArgumentNullException>(bitIndex != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ArithmeticInstruction"/> class.
 /// </summary>
 /// <param name="destination">The destination memory operand.</param>
 /// <param name="source">The source immediate operand.</param>
 protected ArithmeticInstruction(EffectiveAddress destination, Immediate source)
     : this((IRegisterOrMemoryOperand)destination, (ISourceOperand)source)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(destination != null);
     Contract.Requires<ArgumentNullException>(source != null);
     #endregion
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Cmpxchg8b"/> class.
        /// </summary>
        /// <param name="destination">The operand being compared and written to.</param>
        public Cmpxchg8b(EffectiveAddress destination)
        {
            #region Contract
            Contract.Requires<ArgumentNullException>(destination != null);
            #endregion

            this.destination = destination;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Clflush"/> class.
        /// </summary>
        /// <param name="address">The linear address to flush.</param>
        public Clflush(EffectiveAddress address)
        {
            #region Contract
            Contract.Requires<ArgumentNullException>(address != null);
            #endregion

            this.address = address;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Popcnt"/> class.
 /// </summary>
 /// <param name="destination">The register in which the bit's index will be stored.</param>
 /// <param name="subject">The memory operand which is checked.</param>
 public Popcnt(RegisterOperand destination, EffectiveAddress subject)
     : this(destination, (Operand)subject)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(destination != null);
     Contract.Requires<ArgumentNullException>(subject != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Cmpxchg"/> class.
 /// </summary>
 /// <param name="compared">The memory operand being compared.</param>
 /// <param name="source">The source operand.</param>
 public Cmpxchg(EffectiveAddress compared, RegisterOperand source)
     : this((Operand)compared, source)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(compared != null);
     Contract.Requires<ArgumentNullException>(source != null);
     #endregion
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="Lea"/> class.
        /// </summary>
        /// <param name="destination">The destination register operand.</param>
        /// <param name="address">The address.</param>
        public Lea(RegisterOperand destination, EffectiveAddress address)
        {
            #region Contract
            Contract.Requires<ArgumentNullException>(destination != null);
            Contract.Requires<ArgumentNullException>(address != null);
            #endregion

            this.destination = destination;
            this.address = address;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Bound"/> class.
        /// </summary>
        /// <param name="index">The array index to check.</param>
        /// <param name="bounds">Memory address of two (double)words specifying the lower and upper limits of the
        /// array.</param>
        public Bound(RegisterOperand index, EffectiveAddress bounds)
        {
            #region Contract
            Contract.Requires<ArgumentNullException>(index != null);
            Contract.Requires<ArgumentNullException>(bounds != null);
            #endregion

            this.index = index;
            this.bounds = bounds;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Lds"/> class.
        /// </summary>
        /// <param name="destination">The destination operand.</param>
        /// <param name="source">The source operand.</param>
        public Lds(RegisterOperand destination, EffectiveAddress source)
        {
            #region Contract
            Contract.Requires<ArgumentNullException>(destination != null);
            Contract.Requires<ArgumentNullException>(source != null);
            #endregion

            this.destination = destination;
            this.source = source;
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Prefetchl"/> class.
        /// </summary>
        /// <param name="address">The address to prefetch.</param>
        /// <param name="level">The prefetch level.</param>
        public Prefetchl(EffectiveAddress address, PrefetchLevel level)
        {
            #region Contract
            Contract.Requires<ArgumentNullException>(address != null);
            Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(PrefetchLevel), level));
            Contract.Requires<ArgumentException>(level != PrefetchLevel.None);
            #endregion

            this.address = address;
            this.level = level;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="Imul"/> class.
 /// </summary>
 /// <param name="destination">The destination operand.</param>
 /// <param name="source">The source operand.</param>
 /// <param name="multiplier">The multiplier.</param>
 public Imul(RegisterOperand destination, EffectiveAddress source, Immediate multiplier)
     : this(destination, (Operand)source, (Operand)multiplier)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(multiplier != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Adc"/> class.
 /// </summary>
 /// <param name="destination">The destination register operand.</param>
 /// <param name="source">The source register or memory operand.</param>
 public Adc(RegisterOperand destination, EffectiveAddress source)
     : base(destination, source)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(destination != null);
     Contract.Requires<ArgumentException>(destination.Register.IsGeneralPurposeRegister());
     Contract.Requires<ArgumentNullException>(source != null);
     #endregion
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Bound"/> class.
 /// </summary>
 /// <param name="index">The array index to check.</param>
 /// <param name="bounds">Memory address of two (double)words specifying the lower and upper limits of the
 /// array.</param>
 public Bound(RegisterOperand index, EffectiveAddress bounds)
 {
     this.index = index;
     this.bounds = bounds;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="Set"/> class.
 /// </summary>
 /// <param name="destination">The destination memory operand.</param>
 /// <param name="condition">The condition on which this instruction executes.</param>
 public Set(EffectiveAddress destination, InstructionCondition condition)
     : this((Operand)destination, condition)
 {
     #region Contract
     Contract.Requires<ArgumentNullException>(destination != null);
     Contract.Requires<InvalidEnumArgumentException>(Enum.IsDefined(typeof(InstructionCondition), condition));
     Contract.Requires<ArgumentException>(condition != InstructionCondition.None);
     #endregion
 }