public CodeExpression GetExpression(CodeExpression src)
			{
				CodeExpression baseExpression = new CodeBinaryOperatorExpression(
					src,
					CodeBinaryOperatorType.BitwiseAnd,
					new CodePrimitiveExpression((uint)(((1u << (byte)(EndIdx - StartIdx + 1)) - 1) << (byte)StartIdx))
				);
				if (StartIdx != 0)
				{
					baseExpression = new CodeBinaryOperatorExpression(
						baseExpression,
						CodeBinaryOperatorType.ShiftRight,
						new CodePrimitiveExpression((int)StartIdx)
					);
				}
				return Utils.WrapInCast(
					baseExpression,
					(byte)Length
				);
			}
		public void WriteConditionalEmit(CodeScopeStatement con, InstructionForm overridenForm, bool ignoreOtherOverrides = false)
		{
			if (Conditions.Count == 0)
				throw new Exception("There are no conditions to the override!");
			if (!ignoreOtherOverrides && CanGenSegmentSwitch(overridenForm))
			{
				CodeSwitchStatement sw = new CodeSwitchStatement(
					new CodeFieldReferenceExpression(
						new CodeThisReferenceExpression(),
						overridenForm.GetArgName(FieldTypeRegistry.Segment.ID, 1, Conditions[0].ArgIndexToCheck)
					)
				);
				for (int i = 0; i < overridenForm.Overrides.Count; i++)
				{
					CodeCaseStatement cs = new CodeCaseStatement(
						new CodeFieldReferenceExpression(
							StaticTypeReferences.SegmentExpression,
							overridenForm.Overrides[i].Conditions[0].RegisterToCompareTo
						)
					);
					CodeScopeStatement cst = new CodeScopeStatement();
					overridenForm.Overrides[i].NewForm.WriteEmit(cst, true);
					cst.Statements.Add(new CodeBreakStatement());
					cs.Statements.Add(cst);
					sw.Cases.Add(cs);
				}
				CodeDefaultCaseStatement defStat = new CodeDefaultCaseStatement();
				CodeScopeStatement defCont = new CodeScopeStatement();
				overridenForm.WriteEmit(defCont, true);
				defStat.Statements.Add(defCont);
				if (overridenForm.WriteOperations[0].Type != WriteOperationType.Throw)
				{
					defStat.Statements.Add(new CodeBreakStatement());
				}
				sw.Cases.Add(defStat);
				con.Statements.Add(sw);
			}
			else
			{
				CodeScopeStatement tCont = new CodeScopeStatement();
				CodeScopeStatement fCont = new CodeScopeStatement();
				CodeExpression condition = Conditions[0].GetConditionExpression(this, overridenForm);
				for (int i = 1; i < Conditions.Count; i++)
				{
					condition = new CodeBinaryOperatorExpression(
						condition, 
						CodeBinaryOperatorType.BooleanAnd, 
						Conditions[i].GetConditionExpression(this, overridenForm)
					);
				}
				CodeConditionStatement condStat = new CodeConditionStatement(condition, new CodeStatement[] { tCont });
				NewForm.WriteEmit(tCont, true);
				if (!ignoreOtherOverrides)
				{
					condStat.FalseStatements.Add(fCont);
					if (overridenForm.Overrides.Count > 1)
					{
						// If we've gotten here, we know that we are the override at index 0.
						for (int i = 1; i < overridenForm.Overrides.Count; i++)
						{
							CodeScopeStatement eICont = new CodeScopeStatement();
							overridenForm.Overrides[i].WriteConditionalEmit(eICont, overridenForm, true);
							fCont.Statements.Add(eICont);
							fCont = new CodeScopeStatement();
							((CodeConditionStatement)eICont.Statements[0]).FalseStatements.Add(fCont);
						}
					}
					overridenForm.WriteEmit(fCont, true);
				}
				con.Statements.Add(condStat);
			}
		}
		public void Write(CodeMemberMethod mthd)
		{
			if (Operations.Count == 1 && Operations[0].OpType == BitPatternPieceOperation.OperationType.PatternInvoke)
			{
				mthd.Statements.Add(Operations[0].GetExpression());
			}
			else
			{    
				CodeExpression expr = null;
				uint curLength = 0;

				for(int i = Operations.Count - 1; i >= 0; i--)
				{
					if (expr == null)
					{
						expr = Utils.WrapInCast(Operations[i].GetExpression(), (byte)TotalLength);
					}
					else
					{
						expr = new CodeBinaryOperatorExpression(
							Utils.WrapInCast(
								new CodeBinaryOperatorExpression(
									Utils.WrapInCast(Operations[i].GetExpression(), (byte)TotalLength),
									CodeBinaryOperatorType.ShiftLeft,
									new CodePrimitiveExpression((int)curLength)
								),
								(byte)TotalLength
							),
							CodeBinaryOperatorType.BitwiseOr,
							expr
						);
					}
					curLength += Operations[i].Length;
				}

				expr = Utils.WrapInCast(expr, (byte)TotalLength);

				CodeExpression stat = null;
				switch (TotalLength)
				{
					case 0:
						stat = null;
						break;
					case 8:
						stat = new CodeMethodInvokeExpression(
							StaticTypeReferences.Emit_StreamArg,
							"WriteImm8",
							Utils.WrapInCast(expr, 8)
						);
						break;
					case 16:
						stat = new CodeMethodInvokeExpression(
							StaticTypeReferences.Emit_StreamArg,
							"WriteImm16",
							Utils.WrapInCast(expr, 16)
						);
						break;
					case 32:
						stat = new CodeMethodInvokeExpression(
							StaticTypeReferences.Emit_StreamArg,
							"WriteImm32",
							Utils.WrapInCast(expr, 32)
						);
						break;
					default:
						throw new Exception("Unknown total size for a bit pattern piece! The total number of bits must be 8, 16 or 32!");
				}
				if (stat != null)
				{
					mthd.Statements.Add(stat);
				}
			}
		}