public Instruction(Location location, Opcode opcode)
     : this()
 {
     OperationCode = opcode;
     Argument = 0;
     Location = location;
 }

        public IFrameBuilder WithOpcode(Opcode opcode)
        {
            switch(opcode)
            {
                case(Opcode.Binary):
                    _opcode = new byte[] { 0, 0, 1, 0 };
                    break;
                case(Opcode.ConnectionClose):
                    _opcode = new byte[] { 1, 0, 0, 0 };
                    break;
                case (Opcode.Continuation):
                    _isFinal = 0;
                    _opcode = new byte[] { 0, 0, 0, 0 };
                    break;
                case (Opcode.Ping):
                    _opcode = new byte[] { 1, 0, 0, 1 };
                    break;
                case (Opcode.Pong):
                    _opcode = new byte[] { 1, 0, 1, 0 };
                    break;
                case (Opcode.Text):
                    _opcode = new byte[] { 0, 0, 0, 1 };
                    break;
                default:
                    _isFinal = 1;
                    break;
            }

            return this;
        }

        public void Decode()
        {
            Opcode = (Opcode)_machine.Memory[_machine.IP++];

            var b1 = _machine.Memory[_machine.IP++];
            var b2 = _machine.Memory[_machine.IP++];
            var b3 = _machine.Memory[_machine.IP++];

            var left = b1 >> 4;
            var leftPtr = (b3 & 0x80) != 0;
            var leftOffset = (b3 & 0x40) != 0;
            var leftOffsetReg = b2 >> 4;
            var leftType = (b3 >> 4) & 0x03;
            var leftPayload = ReadPayload(left);

            var right = b1 & 0x0F;
            var rightPtr = (b3 & 0x08) != 0;
            var rightOffset = (b3 & 0x04) != 0;
            var rightOffsetReg = b2 & 0x0F;
            var rightType = b3 & 0x03;
            var rightPayload = ReadPayload(right);

            Left.Change(left, leftType, leftPtr, leftOffset, leftOffsetReg, leftPayload);
            Right.Change(right, rightType, rightPtr, rightOffset, rightOffsetReg, rightPayload);
        }

		/// <summary>
		/// push simple value (this, null, false, ...)
		/// </summary>
		void Parser.IGenerator.Push( Opcode opcode )
		{
			var start = ValsAt;
			Vneed( 5 );
			Vpush( unchecked((byte)opcode) );
			Vpush( start );
		}//Parser.IGenerator.Push

		public Instruction (SourceLocation location, Opcode opcode, int arg)
			: this ()
		{
			OperationCode = opcode;
			Argument = arg;
			Location = location;
		}

 // [addedInVersion, removedInVersion[
 public ParserAttribute(Opcode opcode, ClientVersionBuild addedInVersion, ClientVersionBuild removedInVersion)
 {
     if (ClientVersion.AddedInVersion(addedInVersion) && ClientVersion.RemovedInVersion(removedInVersion))
         Opcode = Opcodes.GetOpcode(opcode);
     else
         Opcode = 0;
 }

 public AssemblerInstruction()
 {
     Line = -1;
     Opcode = Opcode.None;
     Left = null;
     Right = null;
 }

		}//Literal
		
		protected override void Binary( Opcode op, byte[] code, ref int at )
		{
			var paren = Parens;
			if( paren )
			{
				Write( '(' );
			}
			if( op == Opcode.Cast )
			{
				Typeref( code, ref at );
				Write( "! " );
				Expression( code, ref at );
				if( paren )
				{
					Write( ')' );
				}
				return;
			}
			Expression( code, ref at );
			Write( ' ' );
			Write( op.Text() );
			Write( ' ' );
			if( (op == Opcode.LogicAnd) || (op == Opcode.LogicOr) )
			{
				at += 4;
			}
			Expression( code, ref at );
			if( paren )
			{
				Write( ')' );
			}
		}//Binary

		}//Binary
		
		protected override void Unary( Opcode op, byte[] code, ref int at )
		{
			var paren = Parens;
			if( paren )
			{
				Write( '(' );
			}
			var text = op.Text();
			var post = op.Postfix();
			if( !post )
			{
				Write( text );
				if( text.Length > 2 )
				{
					Write( ' ' );
				}
			}
			Expression( code, ref at );
			if( post )
			{
				Write( text );
			}
			if( paren )
			{
				Write( ')' );
			}
		}//Unary

 public ShiftOperand(MachineOperand op, Opcode opcode, MachineOperand shAmt)
     : base(op.Width)
 {
     this.Operand = op;
     this.Opcode = opcode;
     this.Shift = shAmt;
 }

		}//Parens
		
		protected override void Literal( Opcode op, byte[] code, ref int at )
		{
			if( op != Opcode.Ident )
			{
				base.Literal( op, code, ref at );
				return;
			}
			var n = code[at++];
			var s = Encoding.UTF8.GetString( code, at, n );
			at += n;
			if( Aliasing == Alias.None )
			{
				if( s[0] == '$' )
				{
					s = s.Substring( 1 );
				}
				if( HasBuiltin( s ) )
				{
					Write( '@' );
				}
				Write( s );
				return;
			}
			if( Inside == Opcode.Dot )
			{
				Name.Append( s );
				return;
			}
			Write( Unalias( s ) );
		}//Literal

        public Request()
        {
            _recursionDesired = true;
            Opcode = Opcode.StandardQuery;

            _questions = new List<Query>();
        }

		public static bool IsServerMessage(Opcode opcode)
		{
			if ((ushort)opcode > 10000 && (ushort)opcode < 20000)
			{
				return true;
			}
			return false;
		}

 public Packet(Opcode opc)
 {
     Opcode = opc;
     Length = 0;  // whole packet size
     Buffer  = new byte[4096];
     currentByteCount = 4;
     currentReadIndex = 4;
 }

 public StorageCommand(Opcode cmdType, string key, uint flags, long expirationTimeInSeconds, int dataSize)
     : base(cmdType)
 {
     _key = key;
     _flags = flags;
     _expirationTimeInSeconds = expirationTimeInSeconds;
     _dataSize = dataSize;
 }

		public static bool IsClientMessage(Opcode opcode)
		{
			if ((ushort)opcode > 0 && (ushort)opcode < 10000)
			{
				return true;
			}
			return false;
		}

 public ObjResponse()
 {
     m_name = "Response";
       m_opcode = Opcode.none;
       m_arguments = new ArrayList();
       m_arguments.Add("");
       m_arguments.Add("");
 }

 public x86CPU(Config cfg)
 {
     _cfg = cfg;
     Registers = new Registers();
     State = new CPUState();
     Memmory = new Memmory(_cfg);
     _opcode = new Opcode();
 }

 private Opcode AddOpcode(Opcode opcode, string destinationLabel)
 {
     opcode.Label = GetNextLabel(true);
     opcode.DestinationLabel = destinationLabel;
     _currentCodeSection.Add(opcode);
     _addBranchDestination = false;
     return opcode;
 }

 private void AddToBreakList(Opcode opcode)
 {
     if (_breakList.Count > 0)
     {
         List<Opcode> list = _breakList[_breakList.Count - 1];
         list.Add(opcode);
     }
 }