/// <summary>
		/// Encodes the specified memory stream.
		/// </summary>
		/// <param name="memoryStream">The memory stream.</param>
		/// <returns></returns>
		public bool Encode (MemoryStream memoryStream)
		{
			int org = 0;

			this.labels = new Dictionary<string, Instruction> ();
			BinaryWriter binaryWriter = new BinaryWriter (memoryStream);

			// The first pass does the computation/optimization
			// The second pass writes the content
			for (int pass = 0; pass < 2; pass++) {
				bool changed;

				if (pass == 1)
					this.Patch ();

				if (pass == 1)
					this.PatchSymbolOffsets ();

				do {
					changed = false;
					UInt32 offset = 0;
					bool bss = false;

					for (int i = 0; i < this.instructions.Count; i++) {
						Instruction instruction = this.instructions [i];

						if (pass == 0)
							instruction.Index = i;

						if (instruction is OrgInstruction) {
							if ((UInt32) instruction.Value < offset)
								org = -((int) offset);

							else
								org = System.Convert.ToInt32 (instruction.Value);

						} else if (instruction is Bits32Instruction)
							this.bits32 = (bool) instruction.Value;

						else if (instruction is OffsetInstruction) {
							offset = (UInt32) instruction.Value;

							if (offset < binaryWriter.BaseStream.Length)
								throw new EngineException ("Wrong offset '" + offset.ToString () + "'.");

							while (pass == 1 && !bss && binaryWriter.BaseStream.Length < instruction.Offset)
								binaryWriter.Write ((byte) 0);

						} else if (instruction is AlignInstruction) {
							if (offset % (UInt32) instruction.Value != 0)
								offset += ((UInt32) instruction.Value - offset % (UInt32) instruction.Value);

							while (pass == 1 && !bss && binaryWriter.BaseStream.Length < instruction.Offset)
								binaryWriter.Write ((byte) 0);

						} else if (instruction is TimesInstruction) {
							TimesInstruction times = instruction as TimesInstruction;

							offset += times.Length;

							while (pass == 1 && !bss && binaryWriter.BaseStream.Length < instruction.Offset)
								binaryWriter.Write ((byte) times.Value);
						}

						if (instruction.Label.Equals (Assembly.FormatLabelName (START_BSS)))
							bss = true;

						if (pass == 0) {
							instruction.Offset = offset;

							if (instruction.Label.Length > 0) {
								if (this.labels.ContainsKey (instruction.Label))
									throw new EngineException (string.Format (
										"The label '{0}' has been defined more than once. Definition 1 = '{1}', Definition 2 = '{2}'",
										instruction.Label, this.labels [instruction.Label], instruction));

								this.labels.Add (instruction.Label, instruction);
							}
						}

						if (pass == 1) {
							if (instruction is AddressOf) {
								AddressOf addressOf = instruction as AddressOf;
								addressOf.Value = (uint) (org + this.GetLabelAddress (addressOf.AddressOfLabel));
							}

							if (instruction.Reference.Length > 0) {
								((UInt32 []) instruction.Value) [0] = this.GetLabelAddress (instruction.Reference);

								if (!instruction.Relative)
									((UInt32 []) instruction.Value) [0] = (UInt32) (org + ((UInt32 []) instruction.Value) [0]);
							}

							if (instruction.RMMemory != null && instruction.RMMemory.Reference.Length > 0)
								instruction.RMMemory.Displacement = (int) (org + this.GetLabelAddress (instruction.RMMemory.Reference) + instruction.RMMemory.DisplacementDelta);
//.........这里部分代码省略.........

		public MetadataVisitor (Assembly asm)
		{
			this.asm = asm;
		}