diff --git a/ICSharpCode.Decompiler/Ast/AstBuilder.cs b/ICSharpCode.Decompiler/Ast/AstBuilder.cs
index 86b62ced5..21c5d73a4 100644
--- a/ICSharpCode.Decompiler/Ast/AstBuilder.cs
+++ b/ICSharpCode.Decompiler/Ast/AstBuilder.cs
@@ -230,7 +230,9 @@ namespace ICSharpCode.Decompiler.Ast
 			foreach (TypeDefinition nestedTypeDef in typeDef.NestedTypes) {
 				if (MemberIsHidden(nestedTypeDef, context.Settings))
 					continue;
-				astType.AddChild(CreateType(nestedTypeDef), TypeDeclaration.MemberRole);
+				var nestedType = CreateType(nestedTypeDef);
+				SetNewModifier(nestedType);
+				astType.AddChild(nestedType, TypeDeclaration.MemberRole);
 			}
 			
 			AttributedNode result = astType;
@@ -626,7 +628,7 @@ namespace ICSharpCode.Decompiler.Ast
 			CreateCodeMappings(methodDef.MetadataToken.ToInt32(), methodDef);
 			MemberMapping methodMapping = methodDef.CreateCodeMapping(this.CodeMappings[methodDef.MetadataToken.ToInt32()]);
 			
-			MethodDeclaration astMethod = new MethodDeclaration();
+			MethodDeclaration astMethod = new MethodDeclaration().WithAnnotation(methodMapping);
 			astMethod.AddAnnotation(methodDef);
 			astMethod.ReturnType = ConvertType(methodDef.ReturnType, methodDef.MethodReturnType);
 			astMethod.Name = CleanName(methodDef.Name);
@@ -637,14 +639,8 @@ namespace ICSharpCode.Decompiler.Ast
 			if (!methodDef.DeclaringType.IsInterface) {
 				if (!methodDef.HasOverrides) {
 					astMethod.Modifiers = ConvertModifiers(methodDef);
-					if (methodDef.IsVirtual ^ !methodDef.IsNewSlot) {
-						try {
-							if (TypesHierarchyHelpers.FindBaseMethods(methodDef).Any())
-								astMethod.Modifiers |= Modifiers.New;
-						} catch (ReferenceResolvingException) {
-							// TODO: add some kind of notification (a comment?) about possible problems with decompiled code due to unresolved references.
-						}
-					}
+					if (methodDef.IsVirtual == methodDef.IsNewSlot)
+						SetNewModifier(astMethod);
 				} else {
 					astMethod.PrivateImplementationType = ConvertType(methodDef.Overrides.First().DeclaringType);
 				}
@@ -674,7 +670,6 @@ namespace ICSharpCode.Decompiler.Ast
 					return op;
 				}
 			}
-			astMethod.WithAnnotation(methodMapping);
 			return astMethod;
 		}
 
@@ -775,10 +770,6 @@ namespace ICSharpCode.Decompiler.Ast
 							}
 						}
 					}
-					if (accessor.IsVirtual ^ !accessor.IsNewSlot) {
-						if (TypesHierarchyHelpers.FindBaseProperties(propDef).Any())
-							astProp.Modifiers |= Modifiers.New;
-					}
 				} catch (ReferenceResolvingException) {
 					// TODO: add some kind of notification (a comment?) about possible problems with decompiled code due to unresolved references.
 				}
@@ -793,7 +784,7 @@ namespace ICSharpCode.Decompiler.Ast
 				
 				astProp.Getter = new Accessor();
 				astProp.Getter.Body = CreateMethodBody(propDef.GetMethod);
-				astProp.AddAnnotation(propDef.GetMethod);
+				astProp.Getter.AddAnnotation(propDef.GetMethod);
 				ConvertAttributes(astProp.Getter, propDef.GetMethod);
 				
 				if ((getterModifiers & Modifiers.VisibilityMask) != (astProp.Modifiers & Modifiers.VisibilityMask))
@@ -818,11 +809,14 @@ namespace ICSharpCode.Decompiler.Ast
 				astProp.Setter.WithAnnotation(methodMapping);
 			}
 			ConvertCustomAttributes(astProp, propDef);
-			
+
+			MemberDeclaration member = astProp;
 			if(propDef.IsIndexer())
-				return ConvertPropertyToIndexer(astProp, propDef);
-			else
-				return astProp;
+				member = ConvertPropertyToIndexer(astProp, propDef);
+			if(!accessor.HasOverrides && !accessor.DeclaringType.IsInterface)
+				if (accessor.IsVirtual == accessor.IsNewSlot)
+					SetNewModifier(member);
+			return member;
 		}
 
 		IndexerDeclaration ConvertPropertyToIndexer(PropertyDeclaration astProp, PropertyDefinition propDef)
@@ -888,9 +882,8 @@ namespace ICSharpCode.Decompiler.Ast
 					astEvent.RemoveAccessor.WithAnnotation(methodMapping);
 				}
 				MethodDefinition accessor = eventDef.AddMethod ?? eventDef.RemoveMethod;
-				if (accessor.IsVirtual ^ !accessor.IsNewSlot) {
-					if (TypesHierarchyHelpers.FindBaseMethods(accessor).Any())
-						astEvent.Modifiers |= Modifiers.New;
+				if (accessor.IsVirtual == accessor.IsNewSlot) {
+					SetNewModifier(astEvent);
 				}
 				return astEvent;
 			}
@@ -920,6 +913,7 @@ namespace ICSharpCode.Decompiler.Ast
 				initializer.Initializer = CreateExpressionForConstant(fieldDef.Constant, fieldDef.FieldType, fieldDef.DeclaringType.IsEnum);
 			}
 			ConvertAttributes(astField, fieldDef);
+			SetNewModifier(astField);
 			return astField;
 		}
 		
@@ -1387,6 +1381,83 @@ namespace ICSharpCode.Decompiler.Ast
 
 			return type.CustomAttributes.Any(attr => attr.AttributeType.FullName == "System.FlagsAttribute");
 		}
+
+		/// <summary>
+		/// Sets new modifier if the member hides some other member from a base type.
+		/// </summary>
+		/// <param name="member">The node of the member which new modifier state should be determined.</param>
+		static void SetNewModifier(AttributedNode member)
+		{
+			try {
+				bool addNewModifier = false;
+				if (member is IndexerDeclaration) {
+					var propertyDef = member.Annotation<PropertyDefinition>();
+					var baseProperties =
+						TypesHierarchyHelpers.FindBaseProperties(propertyDef);
+					addNewModifier = baseProperties.Any();
+				} else
+					addNewModifier = HidesBaseMember(member);
+
+				if (addNewModifier)
+					member.Modifiers |= Modifiers.New;
+			}
+			catch (ReferenceResolvingException) {
+				// TODO: add some kind of notification (a comment?) about possible problems with decompiled code due to unresolved references.
+			}
+		}
+
+		private static bool HidesBaseMember(AttributedNode member)
+		{
+			var memberDefinition = member.Annotation<IMemberDefinition>();
+			bool addNewModifier = false;
+			var methodDefinition = memberDefinition as MethodDefinition;
+			if (methodDefinition != null) {
+				addNewModifier = HidesByName(memberDefinition, includeBaseMethods: false);
+				if (!addNewModifier)
+					addNewModifier = TypesHierarchyHelpers.FindBaseMethods(methodDefinition).Any();
+			} else
+				addNewModifier = HidesByName(memberDefinition, includeBaseMethods: true);
+			return addNewModifier;
+		}
+
+		/// <summary>
+		/// Determines whether any base class member has the same name as the given member.
+		/// </summary>
+		/// <param name="member">The derived type's member.</param>
+		/// <param name="includeBaseMethods">true if names of methods declared in base types should also be checked.</param>
+		/// <returns>true if any base member has the same name as given member, otherwise false.</returns>
+		static bool HidesByName(IMemberDefinition member, bool includeBaseMethods)
+		{
+			Debug.Assert(!(member is PropertyDefinition) || !((PropertyDefinition)member).IsIndexer());
+
+			if (member.DeclaringType.BaseType != null) {
+				var baseTypeRef = member.DeclaringType.BaseType;
+				while (baseTypeRef != null) {
+					var baseType = baseTypeRef.ResolveOrThrow();
+					if (baseType.HasProperties && AnyIsHiddenBy(baseType.Properties, member, m => !m.IsIndexer()))
+						return true;
+					if (baseType.HasEvents && AnyIsHiddenBy(baseType.Events, member))
+						return true;
+					if (baseType.HasFields && AnyIsHiddenBy(baseType.Fields, member))
+						return true;
+					if (includeBaseMethods && baseType.HasMethods
+							&& AnyIsHiddenBy(baseType.Methods, member, m => !m.IsSpecialName))
+						return true;
+					if (baseType.HasNestedTypes && AnyIsHiddenBy(baseType.NestedTypes, member))
+						return true;
+					baseTypeRef = baseType.BaseType;
+				}
+			}
+			return false;
+		}
+
+		static bool AnyIsHiddenBy<T>(IEnumerable<T> members, IMemberDefinition derived, Predicate<T> condition = null)
+			where T : IMemberDefinition
+		{
+			return members.Any(m => m.Name == derived.Name
+				&& (condition == null || condition(m))
+				&& TypesHierarchyHelpers.IsVisibleFromDerived(m, derived.DeclaringType));
+		}
 		
 		/// <summary>
 		/// Gets the local variables for the current decompiled type, method, etc.
diff --git a/ICSharpCode.Decompiler/Ast/TypesHierarchyHelpers.cs b/ICSharpCode.Decompiler/Ast/TypesHierarchyHelpers.cs
index ca1d72f8f..a7cd35a30 100644
--- a/ICSharpCode.Decompiler/Ast/TypesHierarchyHelpers.cs
+++ b/ICSharpCode.Decompiler/Ast/TypesHierarchyHelpers.cs
@@ -27,6 +27,13 @@ namespace ICSharpCode.Decompiler.Ast
 			}
 		}
 
+		/// <summary>
+		/// Determines whether one method overrides or hides another method.
+		/// </summary>
+		/// <param name="parentMethod">The method declared in a base type.</param>
+		/// <param name="childMethod">The method declared in a derived type.</param>
+		/// <returns>true if <paramref name="childMethod"/> hides or overrides <paramref name="parentMethod"/>,
+		/// otherwise false.</returns>
 		public static bool IsBaseMethod(MethodDefinition parentMethod, MethodDefinition childMethod)
 		{
 			if (parentMethod == null)
@@ -44,6 +51,13 @@ namespace ICSharpCode.Decompiler.Ast
 			return FindBaseMethods(childMethod).Any(m => m == parentMethod);// || (parentMethod.HasGenericParameters && m.);
 		}
 
+		/// <summary>
+		/// Determines whether a property overrides or hides another property.
+		/// </summary>
+		/// <param name="parentProperty">The property declared in a base type.</param>
+		/// <param name="childProperty">The property declared in a derived type.</param>
+		/// <returns>true if the <paramref name="childProperty"/> hides or overrides <paramref name="parentProperty"/>,
+		/// otherwise false.</returns>
 		public static bool IsBaseProperty(PropertyDefinition parentProperty, PropertyDefinition childProperty)
 		{
 			if (parentProperty == null)
@@ -69,6 +83,11 @@ namespace ICSharpCode.Decompiler.Ast
 			return FindBaseEvents(childEvent).Any(m => m == parentEvent);
 		}
 
+		/// <summary>
+		/// Finds all methods from base types overridden or hidden by the specified method.
+		/// </summary>
+		/// <param name="method">The method which overrides or hides methods from base types.</param>
+		/// <returns>Methods overriden or hidden by the specified method.</returns>
 		public static IEnumerable<MethodDefinition> FindBaseMethods(MethodDefinition method)
 		{
 			if (method == null)
@@ -79,30 +98,41 @@ namespace ICSharpCode.Decompiler.Ast
 
 			foreach (var baseType in BaseTypes(method.DeclaringType))
 				foreach (var baseMethod in baseType.Item.Methods)
-					if (MatchMethod(baseType.ApplyTo(baseMethod), gMethod) && IsVisbleFrom(baseMethod, method)) {
+					if (MatchMethod(baseType.ApplyTo(baseMethod), gMethod) && IsVisibleFromDerived(baseMethod, method.DeclaringType)) {
 						yield return baseMethod;
-						if (!(baseMethod.IsNewSlot ^ baseMethod.IsVirtual))
+						if (baseMethod.IsNewSlot == baseMethod.IsVirtual)
 							yield break;
 					}
 		}
 
-		public static IEnumerable<PropertyDefinition> FindBaseProperties(PropertyDefinition property, bool ignoreResolveExceptions = false)
+		/// <summary>
+		/// Finds all properties from base types overridden or hidden by the specified property.
+		/// </summary>
+		/// <param name="property">The property which overrides or hides properties from base types.</param>
+		/// <returns>Properties overriden or hidden by the specified property.</returns>
+		public static IEnumerable<PropertyDefinition> FindBaseProperties(PropertyDefinition property)
 		{
 			if (property == null)
 				throw new ArgumentNullException("property");
 
+			if ((property.GetMethod ?? property.SetMethod).HasOverrides)
+				yield break;
+
 			var typeContext = CreateGenericContext(property.DeclaringType);
 			var gProperty = typeContext.ApplyTo(property);
+			bool isIndexer = property.IsIndexer();
 
 			foreach (var baseType in BaseTypes(property.DeclaringType))
 				foreach (var baseProperty in baseType.Item.Properties)
-					if (MatchProperty(baseType.ApplyTo(baseProperty), gProperty) && IsVisbleFrom(baseProperty, property)) {
+					if (MatchProperty(baseType.ApplyTo(baseProperty), gProperty)
+							&& IsVisibleFromDerived(baseProperty, property.DeclaringType)) {
+						if (isIndexer != baseProperty.IsIndexer())
+							continue;
 						yield return baseProperty;
 						var anyPropertyAccessor = baseProperty.GetMethod ?? baseProperty.SetMethod;
-						if (!(anyPropertyAccessor.IsNewSlot ^ anyPropertyAccessor.IsVirtual))
+						if (anyPropertyAccessor.IsNewSlot == anyPropertyAccessor.IsVirtual)
 							yield break;
 					}
-
 		}
 
 		public static IEnumerable<EventDefinition> FindBaseEvents(EventDefinition eventDef)
@@ -115,40 +145,78 @@ namespace ICSharpCode.Decompiler.Ast
 
 			foreach (var baseType in BaseTypes(eventDef.DeclaringType))
 				foreach (var baseEvent in baseType.Item.Events)
-					if (MatchEvent(baseType.ApplyTo(baseEvent), gEvent) && IsVisbleFrom(baseEvent, eventDef)) {
+					if (MatchEvent(baseType.ApplyTo(baseEvent), gEvent) && IsVisibleFromDerived(baseEvent, eventDef.DeclaringType)) {
 						yield return baseEvent;
 						var anyEventAccessor = baseEvent.AddMethod ?? baseEvent.RemoveMethod;
-						if (!(anyEventAccessor.IsNewSlot ^ anyEventAccessor.IsVirtual))
+						if (anyEventAccessor.IsNewSlot == anyEventAccessor.IsVirtual)
 							yield break;
 					}
 
 		}
 
-		private static bool IsVisbleFrom(MethodDefinition baseCandidate, MethodDefinition method)
+		/// <summary>
+		/// Determinates whether member of the base type is visible from a derived type.
+		/// </summary>
+		/// <param name="baseMember">The member which visibility is checked.</param>
+		/// <param name="derivedType">The derived type.</param>
+		/// <returns>true if the member is visible from derived type, othewise false.</returns>
+		public static bool IsVisibleFromDerived(IMemberDefinition baseMember, TypeDefinition derivedType)
 		{
-			if (baseCandidate.IsPrivate)
-				return false;
-			if ((baseCandidate.IsAssembly || baseCandidate.IsFamilyAndAssembly) && baseCandidate.Module != method.Module)
+			if (baseMember == null)
+				throw new ArgumentNullException("baseMember");
+			if (derivedType == null)
+				throw new ArgumentNullException("derivedType");
+
+			var visibility = IsVisibleFromDerived(baseMember);
+			if (visibility.HasValue)
+				return visibility.Value;
+
+			if (baseMember.DeclaringType.Module == derivedType.Module)
+				return true;
+			// TODO: Check also InternalsVisibleToAttribute.
 				return false;
-			return true;
 		}
 
-		private static bool IsVisbleFrom(PropertyDefinition baseCandidate, PropertyDefinition property)
+		private static bool? IsVisibleFromDerived(IMemberDefinition member)
 		{
-			if (baseCandidate.GetMethod != null && property.GetMethod != null && IsVisbleFrom(baseCandidate.GetMethod, property.GetMethod))
-				return true;
-			if (baseCandidate.SetMethod != null && property.SetMethod != null && IsVisbleFrom(baseCandidate.SetMethod, property.SetMethod))
+			MethodAttributes attrs = GetAccessAttributes(member) & MethodAttributes.MemberAccessMask;
+			if (attrs == MethodAttributes.Private)
+				return false;
+			if (attrs == MethodAttributes.Assembly || attrs == MethodAttributes.FamANDAssem)
+				return null;
 				return true;
-			return false;
 		}
 
-		private static bool IsVisbleFrom(EventDefinition baseCandidate, EventDefinition eventDef)
+		private static MethodAttributes GetAccessAttributes(IMemberDefinition member)
 		{
-			if (baseCandidate.AddMethod != null && eventDef.AddMethod != null && IsVisbleFrom(baseCandidate.AddMethod, eventDef.AddMethod))
-				return true;
-			if (baseCandidate.RemoveMethod != null && eventDef.RemoveMethod != null && IsVisbleFrom(baseCandidate.RemoveMethod, eventDef.RemoveMethod))
-				return true;
-			return false;
+			var fld = member as FieldDefinition;
+			if (fld != null)
+				return (MethodAttributes)fld.Attributes;
+
+			var method = member as MethodDefinition;
+			if (method != null)
+				return method.Attributes;
+
+			var prop = member as PropertyDefinition;
+			if (prop != null) {
+				return (prop.GetMethod ?? prop.SetMethod).Attributes;
+		}
+
+			var evnt = member as EventDefinition;
+			if (evnt != null) {
+				return (evnt.AddMethod ?? evnt.RemoveMethod).Attributes;
+			}
+
+			var nestedType = member as TypeDefinition;
+			if (nestedType != null) {
+				if (nestedType.IsNestedPrivate)
+					return MethodAttributes.Private;
+				if (nestedType.IsNestedAssembly || nestedType.IsNestedFamilyAndAssembly)
+					return MethodAttributes.Assembly;
+				return MethodAttributes.Public;
+			}
+
+			throw new NotSupportedException();
 		}
 
 		private static bool MatchMethod(GenericContext<MethodDefinition> candidate, GenericContext<MethodDefinition> method)
@@ -161,7 +229,7 @@ namespace ICSharpCode.Decompiler.Ast
 			if (mCandidate.HasOverrides)
 				return false;
 
-			if (!IsSameType(candidate.ResolveWithContext(mCandidate.ReturnType), method.ResolveWithContext(mMethod.ReturnType)))
+			if (mCandidate.IsSpecialName != method.Item.IsSpecialName)
 				return false;
 
 			if (mCandidate.HasGenericParameters || mMethod.HasGenericParameters) {
@@ -208,9 +276,6 @@ namespace ICSharpCode.Decompiler.Ast
 			if ((mCandidate.GetMethod ?? mCandidate.SetMethod).HasOverrides)
 				return false;
 
-			if (!IsSameType(candidate.ResolveWithContext(mCandidate.PropertyType), property.ResolveWithContext(mProperty.PropertyType)))
-				return false;
-
 			if (mCandidate.HasParameters || mProperty.HasParameters) {
 				if (!mCandidate.HasParameters || !mProperty.HasParameters || mCandidate.Parameters.Count != mProperty.Parameters.Count)
 					return false;
@@ -242,6 +307,9 @@ namespace ICSharpCode.Decompiler.Ast
 
 		private static bool MatchParameters(GenericContext<ParameterDefinition> baseParameterType, GenericContext<ParameterDefinition> parameterType)
 		{
+			if (baseParameterType.Item.IsIn != parameterType.Item.IsIn ||
+					baseParameterType.Item.IsOut != parameterType.Item.IsOut)
+				return false;
 			var baseParam = baseParameterType.ResolveWithContext(baseParameterType.Item.ParameterType);
 			var param = parameterType.ResolveWithContext(parameterType.Item.ParameterType);
 			return IsSameType(baseParam, param);
@@ -254,8 +322,12 @@ namespace ICSharpCode.Decompiler.Ast
 			if (tr1 == null || tr2 == null)
 				return false;
 
+			if (tr1.GetType() != tr2.GetType())
+				return false;
+
 			if (tr1.Name == tr2.Name && tr1.FullName == tr2.FullName)
 				return true;
+
 			return false;
 		}
 
@@ -288,6 +360,10 @@ namespace ICSharpCode.Decompiler.Ast
 		struct GenericContext<T> where T : class
 		{
 			private static readonly ReadOnlyCollection<TypeReference> Empty = new ReadOnlyCollection<TypeReference>(new List<TypeReference>());
+			private static readonly GenericParameter UnresolvedGenericTypeParameter =
+				new DummyGenericParameterProvider(false).DummyParameter;
+			private static readonly GenericParameter UnresolvedGenericMethodParameter =
+				new DummyGenericParameterProvider(true).DummyParameter;
 
 			public readonly T Item;
 			public readonly ReadOnlyCollection<TypeReference> TypeArguments;
@@ -324,28 +400,99 @@ namespace ICSharpCode.Decompiler.Ast
 			public TypeReference ResolveWithContext(TypeReference type)
 			{
 				var genericParameter = type as GenericParameter;
-				if (genericParameter != null && genericParameter.Owner.GenericParameterType == GenericParameterType.Type) {
+				if (genericParameter != null)
+					if (genericParameter.Owner.GenericParameterType == GenericParameterType.Type)
 					return this.TypeArguments[genericParameter.Position];
+					else
+						return genericParameter.Owner.GenericParameterType == GenericParameterType.Type
+							? UnresolvedGenericTypeParameter : UnresolvedGenericMethodParameter;
+				var typeSpecification = type as TypeSpecification;
+				if (typeSpecification != null) {
+					var resolvedElementType = ResolveWithContext(typeSpecification.ElementType);
+					return ReplaceElementType(typeSpecification, resolvedElementType);
 				}
-				var arrayType = type as ArrayType;
+				return type.ResolveOrThrow();
+			}
+
+			private TypeReference ReplaceElementType(TypeSpecification ts, TypeReference newElementType)
+			{
+				var arrayType = ts as ArrayType;
 				if (arrayType != null) {
-					var resolvedElementType = ResolveWithContext(arrayType.ElementType);
-					if (resolvedElementType == null)
-						return null;
-					if (resolvedElementType == arrayType.ElementType)
+					if (newElementType == arrayType.ElementType)
 						return arrayType;
-					var newArrayType = new ArrayType(resolvedElementType, arrayType.Rank);
+					var newArrayType = new ArrayType(newElementType, arrayType.Rank);
 					for (int dimension = 0; dimension < arrayType.Rank; dimension++)
 						newArrayType.Dimensions[dimension] = arrayType.Dimensions[dimension];
 					return newArrayType;
 				}
-				return type.ResolveOrThrow();
+				var byReferenceType = ts as ByReferenceType;
+				if (byReferenceType != null) {
+					return new ByReferenceType(newElementType);
+			}
+				// TODO: should we throw an exception instead calling Resolve method?
+				return ts.ResolveOrThrow();
 			}
 
 			public GenericContext<T2> ApplyTo<T2>(T2 item) where T2 : class
 			{
 				return new GenericContext<T2>(item, this.TypeArguments);
 			}
+
+			private class DummyGenericParameterProvider : IGenericParameterProvider
+			{
+				readonly Mono.Cecil.GenericParameterType type;
+				readonly Mono.Collections.Generic.Collection<GenericParameter> parameters;
+
+				public DummyGenericParameterProvider(bool methodTypeParameter)
+				{
+					type = methodTypeParameter ? Mono.Cecil.GenericParameterType.Method :
+						Mono.Cecil.GenericParameterType.Type;
+					parameters = new Mono.Collections.Generic.Collection<GenericParameter>(1);
+					parameters.Add(new GenericParameter(this));
+		}
+
+				public GenericParameter DummyParameter
+				{
+					get { return parameters[0]; }
+	}
+
+				bool IGenericParameterProvider.HasGenericParameters
+				{
+					get { throw new NotImplementedException(); }
+				}
+
+				bool IGenericParameterProvider.IsDefinition
+				{
+					get { throw new NotImplementedException(); }
+				}
+
+				ModuleDefinition IGenericParameterProvider.Module
+				{
+					get { throw new NotImplementedException(); }
+				}
+
+				Mono.Collections.Generic.Collection<GenericParameter> IGenericParameterProvider.GenericParameters
+				{
+					get { return parameters; }
+				}
+
+				GenericParameterType IGenericParameterProvider.GenericParameterType
+				{
+					get { return type; }
+				}
+
+				MetadataToken IMetadataTokenProvider.MetadataToken
+				{
+					get
+					{
+						throw new NotImplementedException();
+					}
+					set
+					{
+						throw new NotImplementedException();
+					}
+				}
+			}
 		}
 	}
 }
diff --git a/ICSharpCode.Decompiler/DecompilerSettings.cs b/ICSharpCode.Decompiler/DecompilerSettings.cs
index 32b257eda..4d5d62d76 100644
--- a/ICSharpCode.Decompiler/DecompilerSettings.cs
+++ b/ICSharpCode.Decompiler/DecompilerSettings.cs
@@ -209,6 +209,21 @@ namespace ICSharpCode.Decompiler
 			}
 		}
 		
+		bool showXmlDocumentation = true;
+		
+		/// <summary>
+		/// Gets/Sets whether to include XML documentation comments in the decompiled code
+		/// </summary>
+		public bool ShowXmlDocumentation {
+			get { return showXmlDocumentation; }
+			set {
+				if (showXmlDocumentation != value) {
+					showXmlDocumentation = value;
+					OnPropertyChanged("ShowXmlDocumentation");
+				}
+			}
+		}
+		
 		public event PropertyChangedEventHandler PropertyChanged;
 		
 		protected virtual void OnPropertyChanged(string propertyName)
diff --git a/ICSharpCode.Decompiler/Tests/ICSharpCode.Decompiler.Tests.csproj b/ICSharpCode.Decompiler/Tests/ICSharpCode.Decompiler.Tests.csproj
index 90a2db494..b4906c60f 100644
--- a/ICSharpCode.Decompiler/Tests/ICSharpCode.Decompiler.Tests.csproj
+++ b/ICSharpCode.Decompiler/Tests/ICSharpCode.Decompiler.Tests.csproj
@@ -69,7 +69,7 @@
     <None Include="Types\S_EnumSamples.cs" />
     <None Include="CustomAttributes\S_AssemblyCustomAttribute.cs" />
     <Compile Include="Helpers\RemoveCompilerAttribute.cs" />
-    <None Include="Types\S_TypeMemberDeclarations.cs" />
+    <Compile Include="Types\S_TypeMemberDeclarations.cs" />
     <Compile Include="Types\EnumTests.cs" />
     <Compile Include="Types\TypeTests.cs" />
     <Compile Include="DelegateConstruction.cs" />
@@ -107,4 +107,4 @@
     <None Include="StackTests\StackTests.il" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
-</Project>
+</Project>
\ No newline at end of file
diff --git a/ICSharpCode.Decompiler/Tests/Types/S_TypeMemberDeclarations.cs b/ICSharpCode.Decompiler/Tests/Types/S_TypeMemberDeclarations.cs
index 401bfab61..22458bcfc 100644
--- a/ICSharpCode.Decompiler/Tests/Types/S_TypeMemberDeclarations.cs
+++ b/ICSharpCode.Decompiler/Tests/Types/S_TypeMemberDeclarations.cs
@@ -428,8 +428,8 @@ namespace IndexerOverrideRestrictedAccessorOnly
 		}
 	}
 }
-//$$ PropertyHiding
-namespace PropertyHiding
+//$$ HideProperty
+namespace HideProperty
 {
 	public class A
 	{
@@ -467,8 +467,397 @@ namespace PropertyHiding
 		}
 	}
 }
-//$$ IndexerHidingGeneric
-namespace IndexerHidingGeneric
+//$$ HideMembers
+namespace HideMembers
+{
+	public class A
+	{
+		public int F;
+		public int Prop
+		{
+			get
+			{
+				return 3;
+			}
+		}
+		public int G
+		{
+			get
+			{
+				return 3;
+			}
+		}
+	}
+	public class B : A
+	{
+		public new int F
+		{
+			get
+			{
+				return 3;
+			}
+		}
+		public new string Prop
+		{
+			get
+			{
+				return "a";
+			}
+		}
+	}
+	public class C : A
+	{
+		public new int G;
+	}
+	public class D : A
+	{
+		public new void F()
+		{
+		}
+	}
+	public class D1 : D
+	{
+		public new int F;
+	}
+	public class E : A
+	{
+		private new class F
+		{
+		}
+	}
+}
+//$$ HideMembers2
+namespace HideMembers2
+{
+	public class G
+	{
+		public int Item
+		{
+			get
+			{
+				return 1;
+			}
+		}
+	}
+	public class G2 : G
+	{
+		public int this[int i]
+		{
+			get
+			{
+				return 2;
+			}
+		}
+	}
+	public class G3 : G2
+	{
+		public new int Item
+		{
+			get
+			{
+				return 4;
+			}
+		}
+	}
+	public class H
+	{
+		public int this[int j]
+		{
+			get
+			{
+				return 0;
+			}
+		}
+	}
+	public class H2 : H
+	{
+		public int Item
+		{
+			get
+			{
+				return 2;
+			}
+		}
+	}
+	public class H3 : H2
+	{
+		public new string this[int j]
+		{
+			get
+			{
+				return null;
+			}
+		}
+	}
+}
+//$$ HideMembers2a
+namespace HideMembers2a
+{
+	public interface IA
+	{
+		int this[int i]
+		{
+			get;
+		}
+	}
+	public class A : IA
+	{
+		int IA.this[int i]
+		{
+			get
+			{
+				throw new NotImplementedException();
+			}
+		}
+	}
+	public class A1 : A
+	{
+		public int this[int i]
+		{
+			get
+			{
+				return 3;
+			}
+		}
+	}
+}
+//$$ HideMembers3
+namespace HideMembers3
+{
+	public class G<T>
+	{
+		public void M1(T p)
+		{
+		}
+		public int M2(int t)
+		{
+			return 3;
+		}
+	}
+	public class G1<T> : G<int>
+	{
+		public new int M1(int i)
+		{
+			return 0;
+		}
+		public int M2(T i)
+		{
+			return 2;
+		}
+	}
+	public class G2<T> : G<int>
+	{
+		public int M1(T p)
+		{
+			return 4;
+		}
+	}
+	public class J
+	{
+		public int P
+		{
+			get
+			{
+				return 2;
+			}
+		}
+	}
+	public class J2 : J
+	{
+		public int get_P;
+	}
+}
+//$$ HideMembers4
+namespace HideMembers4
+{
+	public class A
+	{
+		public void M<T>(T t)
+		{
+		}
+	}
+	public class A1 : A
+	{
+		public new void M<K>(K t)
+		{
+		}
+		public void M(int t)
+		{
+		}
+	}
+	public class B
+	{
+		public void M<T>()
+		{
+		}
+		public void M1<T>()
+		{
+		}
+		public void M2<T>(T t)
+		{
+		}
+	}
+	public class B1 : B
+	{
+		public void M<T1, T2>()
+		{
+		}
+		public new void M1<R>()
+		{
+		}
+		public new void M2<R>(R r)
+		{
+		}
+	}
+	public class C<T>
+	{
+		public void M<TT>(T t)
+		{
+		}
+	}
+	public class C1<K> : C<K>
+	{
+		public void M<TT>(TT t)
+		{
+		}
+	}
+}
+//$$ HideMembers5
+namespace HideMembers5
+{
+	public class A
+	{
+		public void M(int t)
+		{
+		}
+	}
+	public class A1 : A
+	{
+		public void M(ref int t)
+		{
+		}
+	}
+	public class B
+	{
+		public void M(ref int l)
+		{
+		}
+	}
+	public class B1 : B
+	{
+		public void M(out int l)
+		{
+			l = 2;
+		}
+		public void M(ref long l)
+		{
+		}
+	}
+}
+//$$ HideMemberSkipNotVisible
+namespace HideMemberSkipNotVisible
+{
+	public class A
+	{
+		protected int F;
+		protected string P
+		{
+			get
+			{
+				return null;
+			}
+		}
+	}
+	public class B : A
+	{
+		private new string F;
+		private new int P
+		{
+			set
+			{
+			}
+		}
+	}
+}
+//$$ HideNestedClass
+namespace HideNestedClass
+{
+	public class A
+	{
+		public class N1
+		{
+		}
+		protected class N2
+		{
+		}
+		private class N3
+		{
+		}
+		internal class N4
+		{
+		}
+		protected internal class N5
+		{
+		}
+	}
+	public class B : A
+	{
+		public new int N1;
+		public new int N2;
+		public int N3;
+		public new int N4;
+		public new int N5;
+	}
+}
+//$$ HidePropertyReservedMethod
+namespace HidePropertyReservedMethod
+{
+	public class A
+	{
+		public int P
+		{
+			get
+			{
+				return 1;
+			}
+		}
+	}
+	public class B : A
+	{
+		public int get_P()
+		{
+			return 2;
+		}
+		public void set_P(int value)
+		{
+		}
+	}
+}
+//$$ HideIndexerDiffAccessor
+namespace HideIndexerDiffAccessor
+{
+	public class A
+	{
+		public int this[int i]
+		{
+			get
+			{
+				return 2;
+			}
+		}
+	}
+	public class B : A
+	{
+		public new int this[int j]
+		{
+			set
+			{
+			}
+		}
+	}
+}
+//$$ HideIndexerGeneric
+namespace HideIndexerGeneric
 {
 	public class A<T>
 	{
@@ -515,8 +904,8 @@ namespace IndexerHidingGeneric
 		}
 	}
 }
-//$$ MethodHiding
-namespace MethodHiding
+//$$ HideMethod
+namespace HideMethod
 {
 	public class A
 	{
@@ -539,8 +928,8 @@ namespace MethodHiding
 		}
 	}
 }
-//$$ MethodHideGeneric
-namespace MethodHideGeneric
+//$$ HideMethodGeneric
+namespace HideMethodGeneric
 {
 	public class A<T>
 	{
@@ -583,8 +972,8 @@ namespace MethodHideGeneric
 		}
 	}
 }
-//$$ MethodHideGenericSkipPrivate
-namespace MethodHideGenericSkipPrivate
+//$$ HideMethodGenericSkipPrivate
+namespace HideMethodGenericSkipPrivate
 {
 	public class A<T>
 	{
@@ -617,8 +1006,8 @@ namespace MethodHideGenericSkipPrivate
 		}
 	}
 }
-//$$ MethodHideGeneric2
-namespace MethodHideGeneric2
+//$$ HideMethodGeneric2
+namespace HideMethodGeneric2
 {
 	public class A
 	{
@@ -669,8 +1058,51 @@ namespace MethodHideGeneric2
 		}
 	}
 }
-//$$ EventHiding
-namespace EventHiding
+//$$ HideMethodDiffSignatures
+namespace HideMethodDiffSignatures
+{
+	public class C1<T>
+	{
+		public virtual void M(T arg)
+		{
+		}
+	}
+	public class C2<T1, T2> : C1<T2>
+	{
+		public new virtual void M(T2 arg)
+		{
+		}
+	}
+	public class C3 : C2<int, bool>
+	{
+		public new virtual void M(bool arg)
+		{
+		}
+	}
+}
+//$$ HideMethodStatic
+namespace HideMethodStatic
+{
+	public class A
+	{
+		public int N
+		{
+			get
+			{
+				return 0;
+			}
+		}
+	}
+	public class B
+	{
+		public int N()
+		{
+			return 0;
+		}
+	}
+}
+//$$ HideEvent
+namespace HideEvent
 {
 	public class A
 	{
diff --git a/ILSpy/AboutPage.cs b/ILSpy/AboutPage.cs
index 9116d0e6a..c80286d55 100644
--- a/ILSpy/AboutPage.cs
+++ b/ILSpy/AboutPage.cs
@@ -178,7 +178,7 @@ namespace ICSharpCode.ILSpy
 		{
 			var tcs = new TaskCompletionSource<AvailableVersionInfo>();
 			WebClient wc = new WebClient();
-			wc.Proxy = new WebProxy() { UseDefaultCredentials = true };
+			wc.UseDefaultCredentials = true;
 			wc.DownloadDataCompleted += delegate(object sender, DownloadDataCompletedEventArgs e) {
 				if (e.Error != null) {
 					tcs.SetException(e.Error);
diff --git a/ILSpy/CSharpLanguage.cs b/ILSpy/CSharpLanguage.cs
index 0f1cc6e19..865d9c2e0 100644
--- a/ILSpy/CSharpLanguage.cs
+++ b/ILSpy/CSharpLanguage.cs
@@ -32,6 +32,7 @@ using ICSharpCode.Decompiler;
 using ICSharpCode.Decompiler.Ast;
 using ICSharpCode.Decompiler.Ast.Transforms;
 using ICSharpCode.ILSpy.Baml;
+using ICSharpCode.ILSpy.XmlDoc;
 using ICSharpCode.NRefactory.CSharp;
 using Mono.Cecil;
 
@@ -89,8 +90,7 @@ namespace ICSharpCode.ILSpy
 			WriteCommentLine(output, TypeToString(method.DeclaringType, includeNamespace: true));
 			AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: method.DeclaringType, isSingleMember: true);
 			codeDomBuilder.AddMethod(method);
-			codeDomBuilder.RunTransformations(transformAbortCondition);
-			codeDomBuilder.GenerateCode(output);
+			RunTransformsAndGenerateCode(codeDomBuilder, output, options);
 			OnDecompilationFinished(new DecompileEventArgs { CodeMappings = codeDomBuilder.CodeMappings, LocalVariables = codeDomBuilder.LocalVariables, DecompiledMemberReferences = codeDomBuilder.DecompiledMemberReferences });
 		}
 		
@@ -99,8 +99,7 @@ namespace ICSharpCode.ILSpy
 			WriteCommentLine(output, TypeToString(property.DeclaringType, includeNamespace: true));
 			AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: property.DeclaringType, isSingleMember: true);
 			codeDomBuilder.AddProperty(property);
-			codeDomBuilder.RunTransformations(transformAbortCondition);
-			codeDomBuilder.GenerateCode(output);
+			RunTransformsAndGenerateCode(codeDomBuilder, output, options);
 			OnDecompilationFinished(new DecompileEventArgs { CodeMappings = codeDomBuilder.CodeMappings, LocalVariables = codeDomBuilder.LocalVariables, DecompiledMemberReferences = codeDomBuilder.DecompiledMemberReferences });
 		}
 		
@@ -109,8 +108,7 @@ namespace ICSharpCode.ILSpy
 			WriteCommentLine(output, TypeToString(field.DeclaringType, includeNamespace: true));
 			AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: field.DeclaringType, isSingleMember: true);
 			codeDomBuilder.AddField(field);
-			codeDomBuilder.RunTransformations(transformAbortCondition);
-			codeDomBuilder.GenerateCode(output);
+			RunTransformsAndGenerateCode(codeDomBuilder, output, options);
 			OnDecompilationFinished(new DecompileEventArgs { DecompiledMemberReferences = codeDomBuilder.DecompiledMemberReferences });
 		}
 		
@@ -119,8 +117,7 @@ namespace ICSharpCode.ILSpy
 			WriteCommentLine(output, TypeToString(ev.DeclaringType, includeNamespace: true));
 			AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: ev.DeclaringType, isSingleMember: true);
 			codeDomBuilder.AddEvent(ev);
-			codeDomBuilder.RunTransformations(transformAbortCondition);
-			codeDomBuilder.GenerateCode(output);
+			RunTransformsAndGenerateCode(codeDomBuilder, output, options);
 			OnDecompilationFinished(new DecompileEventArgs { CodeMappings = codeDomBuilder.CodeMappings, LocalVariables = codeDomBuilder.LocalVariables, DecompiledMemberReferences = codeDomBuilder.DecompiledMemberReferences });
 		}
 		
@@ -128,11 +125,18 @@ namespace ICSharpCode.ILSpy
 		{
 			AstBuilder codeDomBuilder = CreateAstBuilder(options, currentType: type);
 			codeDomBuilder.AddType(type);
-			codeDomBuilder.RunTransformations(transformAbortCondition);
-			codeDomBuilder.GenerateCode(output);
+			RunTransformsAndGenerateCode(codeDomBuilder, output, options);
 			OnDecompilationFinished(new DecompileEventArgs { CodeMappings = codeDomBuilder.CodeMappings, LocalVariables = codeDomBuilder.LocalVariables, DecompiledMemberReferences = codeDomBuilder.DecompiledMemberReferences });
 		}
 		
+		void RunTransformsAndGenerateCode(AstBuilder astBuilder, ITextOutput output, DecompilationOptions options)
+		{
+			astBuilder.RunTransformations(transformAbortCondition);
+			if (options.DecompilerSettings.ShowXmlDocumentation)
+				AddXmlDocTransform.Run(astBuilder.CompilationUnit);
+			astBuilder.GenerateCode(output);
+		}
+		
 		public override void DecompileAssembly(LoadedAssembly assembly, ITextOutput output, DecompilationOptions options)
 		{
 			if (options.FullDecompilation && options.SaveAsProjectDirectory != null) {
diff --git a/ILSpy/ILSpy.csproj b/ILSpy/ILSpy.csproj
index dbe8416ca..baadb3c3d 100644
--- a/ILSpy/ILSpy.csproj
+++ b/ILSpy/ILSpy.csproj
@@ -162,6 +162,7 @@
     <Compile Include="TreeNodes\Analyzer\AnalyzedPropertyAccessorsTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedPropertyOverridesTreeNode.cs" />
     <Compile Include="TreeNodes\Analyzer\AnalyzedPropertyTreeNode.cs" />
+    <Compile Include="XmlDoc\AddXmlDocTransform.cs" />
     <Compile Include="XmlDoc\XmlDocKeyProvider.cs" />
     <Compile Include="XmlDoc\XmlDocLoader.cs" />
     <Compile Include="XmlDoc\XmlDocRenderer.cs" />
diff --git a/ILSpy/LoadedAssembly.cs b/ILSpy/LoadedAssembly.cs
index 29cc0c59e..8285be9ae 100644
--- a/ILSpy/LoadedAssembly.cs
+++ b/ILSpy/LoadedAssembly.cs
@@ -88,24 +88,28 @@ namespace ICSharpCode.ILSpy
 			// runs on background thread
 			ReaderParameters p = new ReaderParameters();
 			p.AssemblyResolver = new MyAssemblyResolver(this);
-			try {
-				if (DecompilerSettingsPanel.CurrentDecompilerSettings.UseDebugSymbols) {
-					SetSymbolSettings(p);
+			AssemblyDefinition asm = AssemblyDefinition.ReadAssembly(fileName, p);
+			if (DecompilerSettingsPanel.CurrentDecompilerSettings.UseDebugSymbols) {
+				try {
+					LoadSymbols(asm.MainModule);
+				} catch (IOException) {
+				} catch (UnauthorizedAccessException) {
+				} catch (InvalidOperationException) {
+					// ignore any errors during symbol loading
 				}
-				return AssemblyDefinition.ReadAssembly(fileName, p);
-			} finally {
-				if (p.SymbolStream != null)
-					p.SymbolStream.Dispose();
 			}
+			return asm;
 		}
 		
-		private void SetSymbolSettings(ReaderParameters p)
+		private void LoadSymbols(ModuleDefinition module)
 		{
 			// search for pdb in same directory as dll
 			string pdbName = Path.Combine(Path.GetDirectoryName(fileName), Path.GetFileNameWithoutExtension(fileName) + ".pdb");
 			if (File.Exists(pdbName)) {
-				p.ReadSymbols = true;
-				p.SymbolStream = File.OpenRead(pdbName);
+				using (Stream s = File.OpenRead(pdbName)) {
+					module.ReadSymbols(new Mono.Cecil.Pdb.PdbReaderProvider().GetSymbolReader(module, s));
+				}
+				return;
 			}
 			
 			// TODO: use symbol cache, get symbols from microsoft
diff --git a/ILSpy/Options/DecompilerSettingsPanel.xaml b/ILSpy/Options/DecompilerSettingsPanel.xaml
index d9f0e938e..ae1a96404 100644
--- a/ILSpy/Options/DecompilerSettingsPanel.xaml
+++ b/ILSpy/Options/DecompilerSettingsPanel.xaml
@@ -7,5 +7,6 @@
 		<CheckBox IsChecked="{Binding YieldReturn}">Decompile enumerators (yield return)</CheckBox>
 		<CheckBox IsChecked="{Binding QueryExpressions}" IsEnabled="{Binding AnonymousMethods}">Decompile query expressions</CheckBox>
 		<CheckBox IsChecked="{Binding UseDebugSymbols}">Use variable names from debug symbols, if available</CheckBox>
+		<CheckBox IsChecked="{Binding ShowXmlDocumentation}">Show XML documentation in decompiled code</CheckBox>
 	</StackPanel>
 </UserControl>
\ No newline at end of file
diff --git a/ILSpy/Options/DecompilerSettingsPanel.xaml.cs b/ILSpy/Options/DecompilerSettingsPanel.xaml.cs
index 99e8474ae..50564416a 100644
--- a/ILSpy/Options/DecompilerSettingsPanel.xaml.cs
+++ b/ILSpy/Options/DecompilerSettingsPanel.xaml.cs
@@ -62,6 +62,7 @@ namespace ICSharpCode.ILSpy
 			s.YieldReturn = (bool?)e.Attribute("yieldReturn") ?? s.YieldReturn;
 			s.QueryExpressions = (bool?)e.Attribute("queryExpressions") ?? s.QueryExpressions;
 			s.UseDebugSymbols = (bool?)e.Attribute("useDebugSymbols") ?? s.UseDebugSymbols;
+			s.ShowXmlDocumentation = (bool?)e.Attribute("xmlDoc") ?? s.ShowXmlDocumentation;
 			return s;
 		}
 		
@@ -73,6 +74,7 @@ namespace ICSharpCode.ILSpy
 			section.SetAttributeValue("yieldReturn", s.YieldReturn);
 			section.SetAttributeValue("queryExpressions", s.QueryExpressions);
 			section.SetAttributeValue("useDebugSymbols", s.UseDebugSymbols);
+			section.SetAttributeValue("xmlDoc", s.ShowXmlDocumentation);
 			
 			XElement existingElement = root.Element("DecompilerSettings");
 			if (existingElement != null)
diff --git a/ILSpy/TextView/DecompilerTextView.cs b/ILSpy/TextView/DecompilerTextView.cs
index 2118568b4..4d938aded 100644
--- a/ILSpy/TextView/DecompilerTextView.cs
+++ b/ILSpy/TextView/DecompilerTextView.cs
@@ -167,17 +167,17 @@ namespace ICSharpCode.ILSpy.TextView
 				} else if (mr is MethodReference) {
 					mr = ((MethodReference)mr).Resolve() ?? mr;
 				}
+				XmlDocRenderer renderer = new XmlDocRenderer();
+				renderer.AppendText(MainWindow.Instance.CurrentLanguage.GetTooltip(mr));
 				XmlDocumentationProvider docProvider = XmlDocLoader.LoadDocumentation(mr.Module);
 				if (docProvider != null) {
-					XmlDocRenderer renderer = new XmlDocRenderer();
-					renderer.AppendText(MainWindow.Instance.CurrentLanguage.GetTooltip(mr));
 					string documentation = docProvider.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
 					if (documentation != null) {
 						renderer.AppendText(Environment.NewLine);
 						renderer.AddXmlDocumentation(documentation);
 					}
-					return renderer.CreateTextBlock();
 				}
+				return renderer.CreateTextBlock();
 			}
 			return null;
 		}
diff --git a/ILSpy/XmlDoc/AddXmlDocTransform.cs b/ILSpy/XmlDoc/AddXmlDocTransform.cs
new file mode 100644
index 000000000..dd0fb3311
--- /dev/null
+++ b/ILSpy/XmlDoc/AddXmlDocTransform.cs
@@ -0,0 +1,80 @@
+// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy of this
+// software and associated documentation files (the "Software"), to deal in the Software
+// without restriction, including without limitation the rights to use, copy, modify, merge,
+// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
+// to whom the Software is furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all copies or
+// substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+// DEALINGS IN THE SOFTWARE.
+
+using System;
+using System.IO;
+using ICSharpCode.NRefactory.CSharp;
+using Mono.Cecil;
+
+namespace ICSharpCode.ILSpy.XmlDoc
+{
+	/// <summary>
+	/// Adds XML documentation for member definitions.
+	/// </summary>
+	static class AddXmlDocTransform
+	{
+		public static void Run(AstNode node)
+		{
+			if (node is AttributedNode) {
+				MemberReference mr = node.Annotation<MemberReference>();
+				if (mr != null && mr.Module != null) {
+					var xmldoc = XmlDocLoader.LoadDocumentation(mr.Module);
+					if (xmldoc != null) {
+						string doc = xmldoc.GetDocumentation(XmlDocKeyProvider.GetKey(mr));
+						if (doc != null) {
+							InsertXmlDocumentation(node, new StringReader(doc));
+						}
+					}
+				}
+				if (!(node is TypeDeclaration))
+					return; // don't recurse into attributed nodes, except for type definitions
+			}
+			foreach (AstNode child in node.Children)
+				Run(child);
+		}
+		
+		static void InsertXmlDocumentation(AstNode node, StringReader r)
+		{
+			// Find the first non-empty line:
+			string firstLine;
+			do {
+				firstLine = r.ReadLine();
+				if (firstLine == null)
+					return;
+			} while (string.IsNullOrWhiteSpace(firstLine));
+			string indentation = firstLine.Substring(0, firstLine.Length - firstLine.TrimStart().Length);
+			string line = firstLine;
+			int skippedWhitespaceLines = 0;
+			// Copy all lines from input to output, except for empty lines at the end.
+			while (line != null) {
+				if (string.IsNullOrWhiteSpace(line)) {
+					skippedWhitespaceLines++;
+				} else {
+					while (skippedWhitespaceLines > 0) {
+						node.Parent.InsertChildBefore(node, new Comment(string.Empty, CommentType.Documentation), AstNode.Roles.Comment);
+						skippedWhitespaceLines--;
+					}
+					if (line.StartsWith(indentation, StringComparison.Ordinal))
+						line = line.Substring(indentation.Length);
+					node.Parent.InsertChildBefore(node, new Comment(" " + line, CommentType.Documentation), AstNode.Roles.Comment);
+				}
+				line = r.ReadLine();
+			}
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.Designer.cs b/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.Designer.cs
new file mode 100644
index 000000000..998cee6fe
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.Designer.cs
@@ -0,0 +1,151 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+namespace ICSharpCode.NRefactory.Demo
+{
+	partial class CSDemo
+	{
+		/// <summary>
+		/// Designer variable used to keep track of non-visual components.
+		/// </summary>
+		private System.ComponentModel.IContainer components = null;
+		
+		/// <summary>
+		/// Disposes resources used by the control.
+		/// </summary>
+		/// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+		protected override void Dispose(bool disposing)
+		{
+			if (disposing) {
+				if (components != null) {
+					components.Dispose();
+				}
+			}
+			base.Dispose(disposing);
+		}
+		
+		/// <summary>
+		/// This method is required for Windows Forms designer support.
+		/// Do not change the method contents inside the source code editor. The Forms designer might
+		/// not be able to load this method if it was changed manually.
+		/// </summary>
+		private void InitializeComponent()
+		{
+			this.splitContainer1 = new System.Windows.Forms.SplitContainer();
+			this.csharpCodeTextBox = new System.Windows.Forms.TextBox();
+			this.resolveButton = new System.Windows.Forms.Button();
+			this.csharpTreeView = new System.Windows.Forms.TreeView();
+			this.csharpGenerateCodeButton = new System.Windows.Forms.Button();
+			this.csharpParseButton = new System.Windows.Forms.Button();
+			((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
+			this.splitContainer1.Panel1.SuspendLayout();
+			this.splitContainer1.Panel2.SuspendLayout();
+			this.splitContainer1.SuspendLayout();
+			this.SuspendLayout();
+			// 
+			// splitContainer1
+			// 
+			this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
+			this.splitContainer1.Location = new System.Drawing.Point(0, 0);
+			this.splitContainer1.Name = "splitContainer1";
+			this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal;
+			// 
+			// splitContainer1.Panel1
+			// 
+			this.splitContainer1.Panel1.Controls.Add(this.csharpCodeTextBox);
+			// 
+			// splitContainer1.Panel2
+			// 
+			this.splitContainer1.Panel2.Controls.Add(this.resolveButton);
+			this.splitContainer1.Panel2.Controls.Add(this.csharpTreeView);
+			this.splitContainer1.Panel2.Controls.Add(this.csharpGenerateCodeButton);
+			this.splitContainer1.Panel2.Controls.Add(this.csharpParseButton);
+			this.splitContainer1.Size = new System.Drawing.Size(475, 406);
+			this.splitContainer1.SplitterDistance = 178;
+			this.splitContainer1.TabIndex = 1;
+			// 
+			// csharpCodeTextBox
+			// 
+			this.csharpCodeTextBox.AcceptsReturn = true;
+			this.csharpCodeTextBox.AcceptsTab = true;
+			this.csharpCodeTextBox.Dock = System.Windows.Forms.DockStyle.Fill;
+			this.csharpCodeTextBox.Font = new System.Drawing.Font("Courier New", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
+			this.csharpCodeTextBox.HideSelection = false;
+			this.csharpCodeTextBox.Location = new System.Drawing.Point(0, 0);
+			this.csharpCodeTextBox.Multiline = true;
+			this.csharpCodeTextBox.Name = "csharpCodeTextBox";
+			this.csharpCodeTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Both;
+			this.csharpCodeTextBox.Size = new System.Drawing.Size(475, 178);
+			this.csharpCodeTextBox.TabIndex = 0;
+			this.csharpCodeTextBox.Text = "using System;\r\nclass Test\r\n{\r\n    public void Main(string[] args)\r\n    {\r\n       " +
+			"  Console.WriteLine(\"Hello, World\");\r\n    }\r\n}";
+			this.csharpCodeTextBox.WordWrap = false;
+			this.csharpCodeTextBox.TextChanged += new System.EventHandler(this.CsharpCodeTextBoxTextChanged);
+			// 
+			// resolveButton
+			// 
+			this.resolveButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
+			this.resolveButton.Location = new System.Drawing.Point(187, 3);
+			this.resolveButton.Name = "resolveButton";
+			this.resolveButton.Size = new System.Drawing.Size(100, 23);
+			this.resolveButton.TabIndex = 3;
+			this.resolveButton.Text = "Resolve";
+			this.resolveButton.UseVisualStyleBackColor = true;
+			this.resolveButton.Click += new System.EventHandler(this.ResolveButtonClick);
+			// 
+			// csharpTreeView
+			// 
+			this.csharpTreeView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+									| System.Windows.Forms.AnchorStyles.Left) 
+									| System.Windows.Forms.AnchorStyles.Right)));
+			this.csharpTreeView.HideSelection = false;
+			this.csharpTreeView.Location = new System.Drawing.Point(3, 32);
+			this.csharpTreeView.Name = "csharpTreeView";
+			this.csharpTreeView.Size = new System.Drawing.Size(467, 189);
+			this.csharpTreeView.TabIndex = 2;
+			this.csharpTreeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.CSharpTreeViewAfterSelect);
+			// 
+			// csharpGenerateCodeButton
+			// 
+			this.csharpGenerateCodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
+			this.csharpGenerateCodeButton.Location = new System.Drawing.Point(293, 2);
+			this.csharpGenerateCodeButton.Name = "csharpGenerateCodeButton";
+			this.csharpGenerateCodeButton.Size = new System.Drawing.Size(100, 23);
+			this.csharpGenerateCodeButton.TabIndex = 1;
+			this.csharpGenerateCodeButton.Text = "Generate";
+			this.csharpGenerateCodeButton.UseVisualStyleBackColor = true;
+			this.csharpGenerateCodeButton.Click += new System.EventHandler(this.CSharpGenerateCodeButtonClick);
+			// 
+			// csharpParseButton
+			// 
+			this.csharpParseButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
+			this.csharpParseButton.Location = new System.Drawing.Point(81, 3);
+			this.csharpParseButton.Name = "csharpParseButton";
+			this.csharpParseButton.Size = new System.Drawing.Size(100, 23);
+			this.csharpParseButton.TabIndex = 0;
+			this.csharpParseButton.Text = "Parse";
+			this.csharpParseButton.UseVisualStyleBackColor = true;
+			this.csharpParseButton.Click += new System.EventHandler(this.CSharpParseButtonClick);
+			// 
+			// CSDemo
+			// 
+			this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+			this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+			this.Controls.Add(this.splitContainer1);
+			this.Name = "CSDemo";
+			this.Size = new System.Drawing.Size(475, 406);
+			this.splitContainer1.Panel1.ResumeLayout(false);
+			this.splitContainer1.Panel1.PerformLayout();
+			this.splitContainer1.Panel2.ResumeLayout(false);
+			((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
+			this.splitContainer1.ResumeLayout(false);
+			this.ResumeLayout(false);
+		}
+		private System.Windows.Forms.Button csharpParseButton;
+		private System.Windows.Forms.Button csharpGenerateCodeButton;
+		private System.Windows.Forms.TreeView csharpTreeView;
+		private System.Windows.Forms.Button resolveButton;
+		private System.Windows.Forms.TextBox csharpCodeTextBox;
+		private System.Windows.Forms.SplitContainer splitContainer1;
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.cs b/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.cs
new file mode 100644
index 000000000..d667596de
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.cs
@@ -0,0 +1,232 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.Drawing;
+using System.IO;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+
+using ICSharpCode.NRefactory.CSharp;
+using ICSharpCode.NRefactory.CSharp.Resolver;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
+
+namespace ICSharpCode.NRefactory.Demo
+{
+	/// <summary>
+	/// Description of CSDemo.
+	/// </summary>
+	public partial class CSDemo : UserControl
+	{
+		public CSDemo()
+		{
+			//
+			// The InitializeComponent() call is required for Windows Forms designer support.
+			//
+			InitializeComponent();
+			
+			if (LicenseManager.UsageMode != LicenseUsageMode.Designtime) {
+				csharpCodeTextBox.SelectAll();
+				CSharpParseButtonClick(null, null);
+				resolveButton.UseWaitCursor = true;
+				ThreadPool.QueueUserWorkItem(
+					delegate {
+						builtInLibs.Value.ToString();
+						BeginInvoke(new Action(delegate { resolveButton.UseWaitCursor = false; }));
+					});
+			}
+		}
+		
+		CompilationUnit compilationUnit;
+		
+		void CSharpParseButtonClick(object sender, EventArgs e)
+		{
+			CSharpParser parser = new CSharpParser();
+			compilationUnit = parser.Parse(new StringReader(csharpCodeTextBox.Text));
+			csharpTreeView.Nodes.Clear();
+			foreach (var element in compilationUnit.Children) {
+				csharpTreeView.Nodes.Add(MakeTreeNode(element));
+			}
+			SelectCurrentNode(csharpTreeView.Nodes);
+			resolveButton.Enabled = true;
+		}
+		
+		TreeNode MakeTreeNode(AstNode node)
+		{
+			TreeNode t = new TreeNode(GetNodeTitle(node));
+			t.Tag = node;
+			foreach (AstNode child in node.Children) {
+				t.Nodes.Add(MakeTreeNode(child));
+			}
+			return t;
+		}
+		
+		string GetNodeTitle(AstNode node)
+		{
+			StringBuilder b = new StringBuilder();
+			b.Append(node.Role.ToString());
+			b.Append(": ");
+			b.Append(node.GetType().Name);
+			bool hasProperties = false;
+			foreach (PropertyInfo p in node.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
+				if (p.Name == "NodeType" || p.Name == "IsNull")
+					continue;
+				if (p.PropertyType == typeof(string) || p.PropertyType.IsEnum || p.PropertyType == typeof(bool)) {
+					if (!hasProperties) {
+						hasProperties = true;
+						b.Append(" (");
+					} else {
+						b.Append(", ");
+					}
+					b.Append(p.Name);
+					b.Append(" = ");
+					try {
+						object val = p.GetValue(node, null);
+						b.Append(val != null ? val.ToString() : "**null**");
+					} catch (TargetInvocationException ex) {
+						b.Append("**" + ex.InnerException.GetType().Name + "**");
+					}
+				}
+			}
+			if (hasProperties)
+				b.Append(")");
+			return b.ToString();
+		}
+		
+		bool SelectCurrentNode(TreeNodeCollection c)
+		{
+			int selectionStart = csharpCodeTextBox.SelectionStart;
+			int selectionEnd = selectionStart + csharpCodeTextBox.SelectionLength;
+			foreach (TreeNode t in c) {
+				AstNode node = t.Tag as AstNode;
+				if (node != null
+				    && selectionStart >= GetOffset(csharpCodeTextBox, node.StartLocation)
+				    && selectionEnd <= GetOffset(csharpCodeTextBox, node.EndLocation))
+				{
+					if (selectionStart == selectionEnd
+					    && (selectionStart == GetOffset(csharpCodeTextBox, node.StartLocation)
+					        || selectionStart == GetOffset(csharpCodeTextBox, node.EndLocation)))
+					{
+						// caret is on border of this node; don't expand
+						csharpTreeView.SelectedNode = t;
+					} else {
+						t.Expand();
+						if (!SelectCurrentNode(t.Nodes))
+							csharpTreeView.SelectedNode = t;
+					}
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		void CSharpGenerateCodeButtonClick(object sender, EventArgs e)
+		{
+			StringWriter w = new StringWriter();
+			OutputVisitor output = new OutputVisitor(w, new CSharpFormattingOptions());
+			compilationUnit.AcceptVisitor(output, null);
+			csharpCodeTextBox.Text = w.ToString();
+		}
+		
+		int GetOffset(TextBox textBox, AstLocation location)
+		{
+			return textBox.GetFirstCharIndexFromLine(location.Line - 1) + location.Column - 1;
+		}
+		
+		void CSharpTreeViewAfterSelect(object sender, TreeViewEventArgs e)
+		{
+			AstNode node = e.Node.Tag as AstNode;
+			if (node != null) {
+				int startOffset = GetOffset(csharpCodeTextBox, node.StartLocation);
+				int endOffset = GetOffset(csharpCodeTextBox, node.EndLocation);
+				csharpCodeTextBox.Select(startOffset, endOffset - startOffset);
+			}
+		}
+		
+		Lazy<IList<IProjectContent>> builtInLibs = new Lazy<IList<IProjectContent>>(
+			delegate {
+				Assembly[] assemblies = {
+					typeof(object).Assembly, // mscorlib
+					typeof(Uri).Assembly, // System.dll
+					typeof(System.Linq.Enumerable).Assembly, // System.Core.dll
+//					typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll
+//					typeof(System.Drawing.Bitmap).Assembly, // System.Drawing.dll
+//					typeof(Form).Assembly, // System.Windows.Forms.dll
+					typeof(ICSharpCode.NRefactory.TypeSystem.IProjectContent).Assembly,
+				};
+				IProjectContent[] projectContents = new IProjectContent[assemblies.Length];
+				Stopwatch total = Stopwatch.StartNew();
+				Parallel.For(
+					0, assemblies.Length,
+					delegate (int i) {
+						Stopwatch w = Stopwatch.StartNew();
+						CecilLoader loader = new CecilLoader();
+						projectContents[i] = loader.LoadAssemblyFile(assemblies[i].Location);
+						Debug.WriteLine(Path.GetFileName(assemblies[i].Location) + ": " + w.Elapsed);
+					});
+				Debug.WriteLine("Total: " + total.Elapsed);
+				return projectContents;
+			});
+		
+		void ResolveButtonClick(object sender, EventArgs e)
+		{
+			SimpleProjectContent project = new SimpleProjectContent();
+			TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(project, "dummy.cs");
+			compilationUnit.AcceptVisitor(convertVisitor, null);
+			project.UpdateProjectContent(null, convertVisitor.ParsedFile.TopLevelTypeDefinitions, null, null);
+			
+			List<ITypeResolveContext> projects = new List<ITypeResolveContext>();
+			projects.Add(project);
+			projects.AddRange(builtInLibs.Value);
+			
+			using (var context = new CompositeTypeResolveContext(projects).Synchronize()) {
+				CSharpResolver resolver = new CSharpResolver(context);
+				
+				IResolveVisitorNavigator navigator = null;
+				if (csharpTreeView.SelectedNode != null) {
+					navigator = new NodeListResolveVisitorNavigator(new[] { (AstNode)csharpTreeView.SelectedNode.Tag });
+				}
+				ResolveVisitor visitor = new ResolveVisitor(resolver, convertVisitor.ParsedFile, navigator);
+				visitor.Scan(compilationUnit);
+				csharpTreeView.BeginUpdate();
+				ShowResolveResultsInTree(csharpTreeView.Nodes, visitor);
+				csharpTreeView.EndUpdate();
+			}
+		}
+		
+		void ShowResolveResultsInTree(TreeNodeCollection c, ResolveVisitor v)
+		{
+			foreach (TreeNode t in c) {
+				AstNode node = t.Tag as AstNode;
+				if (node != null) {
+					ResolveResult rr = v.GetResolveResult(node);
+					if (rr != null)
+						t.Text = GetNodeTitle(node) + " " + rr.ToString();
+					else
+						t.Text = GetNodeTitle(node);
+				}
+				ShowResolveResultsInTree(t.Nodes, v);
+			}
+		}
+		
+		void CSharpCodeTextBoxKeyDown(object sender, KeyEventArgs e)
+		{
+			if (e.Control && e.KeyCode == Keys.A) {
+				e.Handled = true;
+				csharpCodeTextBox.SelectAll();
+			}
+		}
+		
+		void CsharpCodeTextBoxTextChanged(object sender, EventArgs e)
+		{
+			resolveButton.Enabled = false;
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.resx b/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.resx
new file mode 100644
index 000000000..1af7de150
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/CSDemo.resx
@@ -0,0 +1,120 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+</root>
\ No newline at end of file
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/ICSharpCode.NRefactory.Demo.csproj b/NRefactory/ICSharpCode.NRefactory.Demo/ICSharpCode.NRefactory.Demo.csproj
index 169dd2a0d..841474f59 100644
--- a/NRefactory/ICSharpCode.NRefactory.Demo/ICSharpCode.NRefactory.Demo.csproj
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/ICSharpCode.NRefactory.Demo.csproj
@@ -40,17 +40,9 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="VBEditDialog.cs">
-      <SubType>Form</SubType>
-    </Compile>
-    <Compile Include="VBEditDialog.Designer.cs">
-      <DependentUpon>VBEditDialog.cs</DependentUpon>
-    </Compile>
-    <Compile Include="VBAstView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="VBAstView.Designer.cs">
-      <DependentUpon>VBAstView.cs</DependentUpon>
+    <Compile Include="CSDemo.cs" />
+    <Compile Include="CSDemo.Designer.cs">
+      <DependentUpon>CSDemo.cs</DependentUpon>
     </Compile>
     <Compile Include="MainForm.cs">
       <SubType>Form</SubType>
@@ -60,9 +52,7 @@
     </Compile>
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="VBDemo.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
+    <Compile Include="VBDemo.cs" />
     <Compile Include="VBDemo.Designer.cs">
       <DependentUpon>VBDemo.cs</DependentUpon>
     </Compile>
@@ -78,11 +68,8 @@
     </ProjectReference>
   </ItemGroup>
   <ItemGroup>
-    <EmbeddedResource Include="VBEditDialog.resx">
-      <DependentUpon>VBEditDialog.cs</DependentUpon>
-    </EmbeddedResource>
-    <EmbeddedResource Include="VBAstView.resx">
-      <DependentUpon>VBAstView.cs</DependentUpon>
+    <EmbeddedResource Include="CSDemo.resx">
+      <DependentUpon>CSDemo.cs</DependentUpon>
     </EmbeddedResource>
     <EmbeddedResource Include="MainForm.resx">
       <DependentUpon>MainForm.cs</DependentUpon>
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.Designer.cs b/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.Designer.cs
index c24f304ab..12c38ffb6 100644
--- a/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.Designer.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.Designer.cs
@@ -30,40 +30,32 @@ namespace ICSharpCode.NRefactory.Demo
 		/// </summary>
 		private void InitializeComponent()
 		{
-			this.tabPage2 = new System.Windows.Forms.TabPage();
+			this.miniToolStrip = new System.Windows.Forms.ToolStrip();
 			this.tabPage1 = new System.Windows.Forms.TabPage();
-			this.splitContainer1 = new System.Windows.Forms.SplitContainer();
-			this.csharpCodeTextBox = new System.Windows.Forms.TextBox();
-			this.resolveButton = new System.Windows.Forms.Button();
-			this.csharpTreeView = new System.Windows.Forms.TreeView();
-			this.csharpGenerateCodeButton = new System.Windows.Forms.Button();
-			this.csharpParseButton = new System.Windows.Forms.Button();
+			this.csDemo1 = new ICSharpCode.NRefactory.Demo.CSDemo();
 			this.tabControl1 = new System.Windows.Forms.TabControl();
-			this.miniToolStrip = new System.Windows.Forms.ToolStrip();
+			this.tabPage2 = new System.Windows.Forms.TabPage();
 			this.vbDemo1 = new ICSharpCode.NRefactory.Demo.VBDemo();
-			this.tabPage2.SuspendLayout();
 			this.tabPage1.SuspendLayout();
-			((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
-			this.splitContainer1.Panel1.SuspendLayout();
-			this.splitContainer1.Panel2.SuspendLayout();
-			this.splitContainer1.SuspendLayout();
 			this.tabControl1.SuspendLayout();
+			this.tabPage2.SuspendLayout();
 			this.SuspendLayout();
 			// 
-			// tabPage2
+			// miniToolStrip
 			// 
-			this.tabPage2.Controls.Add(this.vbDemo1);
-			this.tabPage2.Location = new System.Drawing.Point(4, 22);
-			this.tabPage2.Name = "tabPage2";
-			this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
-			this.tabPage2.Size = new System.Drawing.Size(507, 458);
-			this.tabPage2.TabIndex = 1;
-			this.tabPage2.Text = "VB";
-			this.tabPage2.UseVisualStyleBackColor = true;
+			this.miniToolStrip.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
+			this.miniToolStrip.AutoSize = false;
+			this.miniToolStrip.CanOverflow = false;
+			this.miniToolStrip.Dock = System.Windows.Forms.DockStyle.None;
+			this.miniToolStrip.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden;
+			this.miniToolStrip.Location = new System.Drawing.Point(13, 3);
+			this.miniToolStrip.Name = "miniToolStrip";
+			this.miniToolStrip.Size = new System.Drawing.Size(16, 25);
+			this.miniToolStrip.TabIndex = 3;
 			// 
 			// tabPage1
 			// 
-			this.tabPage1.Controls.Add(this.splitContainer1);
+			this.tabPage1.Controls.Add(this.csDemo1);
 			this.tabPage1.Location = new System.Drawing.Point(4, 22);
 			this.tabPage1.Name = "tabPage1";
 			this.tabPage1.Padding = new System.Windows.Forms.Padding(3);
@@ -72,90 +64,13 @@ namespace ICSharpCode.NRefactory.Demo
 			this.tabPage1.Text = "C#";
 			this.tabPage1.UseVisualStyleBackColor = true;
 			// 
-			// splitContainer1
-			// 
-			this.splitContainer1.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.splitContainer1.Location = new System.Drawing.Point(3, 3);
-			this.splitContainer1.Name = "splitContainer1";
-			this.splitContainer1.Orientation = System.Windows.Forms.Orientation.Horizontal;
-			// 
-			// splitContainer1.Panel1
-			// 
-			this.splitContainer1.Panel1.Controls.Add(this.csharpCodeTextBox);
-			// 
-			// splitContainer1.Panel2
-			// 
-			this.splitContainer1.Panel2.Controls.Add(this.resolveButton);
-			this.splitContainer1.Panel2.Controls.Add(this.csharpTreeView);
-			this.splitContainer1.Panel2.Controls.Add(this.csharpGenerateCodeButton);
-			this.splitContainer1.Panel2.Controls.Add(this.csharpParseButton);
-			this.splitContainer1.Size = new System.Drawing.Size(501, 452);
-			this.splitContainer1.SplitterDistance = 201;
-			this.splitContainer1.TabIndex = 0;
-			// 
-			// csharpCodeTextBox
+			// csDemo1
 			// 
-			this.csharpCodeTextBox.AcceptsReturn = true;
-			this.csharpCodeTextBox.AcceptsTab = true;
-			this.csharpCodeTextBox.Dock = System.Windows.Forms.DockStyle.Fill;
-			this.csharpCodeTextBox.Font = new System.Drawing.Font("Courier New", 9.75F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
-			this.csharpCodeTextBox.HideSelection = false;
-			this.csharpCodeTextBox.Location = new System.Drawing.Point(0, 0);
-			this.csharpCodeTextBox.Multiline = true;
-			this.csharpCodeTextBox.Name = "csharpCodeTextBox";
-			this.csharpCodeTextBox.ScrollBars = System.Windows.Forms.ScrollBars.Both;
-			this.csharpCodeTextBox.Size = new System.Drawing.Size(501, 201);
-			this.csharpCodeTextBox.TabIndex = 0;
-			this.csharpCodeTextBox.Text = "using System;\r\nclass Test\r\n{\r\n    public void Main(string[] args)\r\n    {\r\n       " +
-			"  Console.WriteLine(\"Hello, World\");\r\n    }\r\n}";
-			this.csharpCodeTextBox.WordWrap = false;
-			this.csharpCodeTextBox.TextChanged += new System.EventHandler(this.CsharpCodeTextBoxTextChanged);
-			this.csharpCodeTextBox.KeyDown += new System.Windows.Forms.KeyEventHandler(this.CSharpCodeTextBoxKeyDown);
-			// 
-			// resolveButton
-			// 
-			this.resolveButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.resolveButton.Location = new System.Drawing.Point(200, 3);
-			this.resolveButton.Name = "resolveButton";
-			this.resolveButton.Size = new System.Drawing.Size(100, 23);
-			this.resolveButton.TabIndex = 3;
-			this.resolveButton.Text = "Resolve";
-			this.resolveButton.UseVisualStyleBackColor = true;
-			this.resolveButton.Click += new System.EventHandler(this.ResolveButtonClick);
-			// 
-			// csharpTreeView
-			// 
-			this.csharpTreeView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-									| System.Windows.Forms.AnchorStyles.Left) 
-									| System.Windows.Forms.AnchorStyles.Right)));
-			this.csharpTreeView.HideSelection = false;
-			this.csharpTreeView.Location = new System.Drawing.Point(3, 32);
-			this.csharpTreeView.Name = "csharpTreeView";
-			this.csharpTreeView.Size = new System.Drawing.Size(493, 212);
-			this.csharpTreeView.TabIndex = 2;
-			this.csharpTreeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.CSharpTreeViewAfterSelect);
-			// 
-			// csharpGenerateCodeButton
-			// 
-			this.csharpGenerateCodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.csharpGenerateCodeButton.Location = new System.Drawing.Point(306, 2);
-			this.csharpGenerateCodeButton.Name = "csharpGenerateCodeButton";
-			this.csharpGenerateCodeButton.Size = new System.Drawing.Size(100, 23);
-			this.csharpGenerateCodeButton.TabIndex = 1;
-			this.csharpGenerateCodeButton.Text = "Generate";
-			this.csharpGenerateCodeButton.UseVisualStyleBackColor = true;
-			this.csharpGenerateCodeButton.Click += new System.EventHandler(this.CSharpGenerateCodeButtonClick);
-			// 
-			// csharpParseButton
-			// 
-			this.csharpParseButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.csharpParseButton.Location = new System.Drawing.Point(94, 3);
-			this.csharpParseButton.Name = "csharpParseButton";
-			this.csharpParseButton.Size = new System.Drawing.Size(100, 23);
-			this.csharpParseButton.TabIndex = 0;
-			this.csharpParseButton.Text = "Parse";
-			this.csharpParseButton.UseVisualStyleBackColor = true;
-			this.csharpParseButton.Click += new System.EventHandler(this.CSharpParseButtonClick);
+			this.csDemo1.Dock = System.Windows.Forms.DockStyle.Fill;
+			this.csDemo1.Location = new System.Drawing.Point(3, 3);
+			this.csDemo1.Name = "csDemo1";
+			this.csDemo1.Size = new System.Drawing.Size(501, 452);
+			this.csDemo1.TabIndex = 0;
 			// 
 			// tabControl1
 			// 
@@ -168,17 +83,16 @@ namespace ICSharpCode.NRefactory.Demo
 			this.tabControl1.Size = new System.Drawing.Size(515, 484);
 			this.tabControl1.TabIndex = 0;
 			// 
-			// miniToolStrip
+			// tabPage2
 			// 
-			this.miniToolStrip.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Right)));
-			this.miniToolStrip.AutoSize = false;
-			this.miniToolStrip.CanOverflow = false;
-			this.miniToolStrip.Dock = System.Windows.Forms.DockStyle.None;
-			this.miniToolStrip.GripStyle = System.Windows.Forms.ToolStripGripStyle.Hidden;
-			this.miniToolStrip.Location = new System.Drawing.Point(13, 3);
-			this.miniToolStrip.Name = "miniToolStrip";
-			this.miniToolStrip.Size = new System.Drawing.Size(16, 25);
-			this.miniToolStrip.TabIndex = 3;
+			this.tabPage2.Controls.Add(this.vbDemo1);
+			this.tabPage2.Location = new System.Drawing.Point(4, 22);
+			this.tabPage2.Name = "tabPage2";
+			this.tabPage2.Padding = new System.Windows.Forms.Padding(3);
+			this.tabPage2.Size = new System.Drawing.Size(507, 458);
+			this.tabPage2.TabIndex = 1;
+			this.tabPage2.Text = "VB";
+			this.tabPage2.UseVisualStyleBackColor = true;
 			// 
 			// vbDemo1
 			// 
@@ -196,25 +110,15 @@ namespace ICSharpCode.NRefactory.Demo
 			this.Controls.Add(this.tabControl1);
 			this.Name = "MainForm";
 			this.Text = "NRefactory Demo";
-			this.tabPage2.ResumeLayout(false);
 			this.tabPage1.ResumeLayout(false);
-			this.splitContainer1.Panel1.ResumeLayout(false);
-			this.splitContainer1.Panel1.PerformLayout();
-			this.splitContainer1.Panel2.ResumeLayout(false);
-			((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).EndInit();
-			this.splitContainer1.ResumeLayout(false);
 			this.tabControl1.ResumeLayout(false);
+			this.tabPage2.ResumeLayout(false);
 			this.ResumeLayout(false);
 		}
 		private ICSharpCode.NRefactory.Demo.VBDemo vbDemo1;
-		private System.Windows.Forms.Button resolveButton;
-		private System.Windows.Forms.ToolStrip miniToolStrip;
-		private System.Windows.Forms.TreeView csharpTreeView;
-		private System.Windows.Forms.Button csharpParseButton;
-		private System.Windows.Forms.Button csharpGenerateCodeButton;
-		private System.Windows.Forms.TextBox csharpCodeTextBox;
-		private System.Windows.Forms.SplitContainer splitContainer1;
 		private System.Windows.Forms.TabPage tabPage2;
+		private ICSharpCode.NRefactory.Demo.CSDemo csDemo1;
+		private System.Windows.Forms.ToolStrip miniToolStrip;
 		private System.Windows.Forms.TabPage tabPage1;
 		private System.Windows.Forms.TabControl tabControl1;
 	}
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.cs b/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.cs
index 285428d8f..9633a00f1 100644
--- a/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/MainForm.cs
@@ -29,200 +29,6 @@ namespace ICSharpCode.NRefactory.Demo
 			// The InitializeComponent() call is required for Windows Forms designer support.
 			//
 			InitializeComponent();
-			
-			csharpCodeTextBox.SelectAll();
-			CSharpParseButtonClick(null, null);
-			resolveButton.UseWaitCursor = true;
-			ThreadPool.QueueUserWorkItem(
-				delegate {
-					builtInLibs.Value.ToString();
-					BeginInvoke(new Action(delegate { resolveButton.UseWaitCursor = false; }));
-				});
-		}
-		
-		CompilationUnit compilationUnit;
-		
-		void CSharpParseButtonClick(object sender, EventArgs e)
-		{
-			CSharpParser parser = new CSharpParser();
-			compilationUnit = parser.Parse(new StringReader(csharpCodeTextBox.Text));
-			csharpTreeView.Nodes.Clear();
-			foreach (var element in compilationUnit.Children) {
-				csharpTreeView.Nodes.Add(MakeTreeNode(element));
-			}
-			SelectCurrentNode(csharpTreeView.Nodes);
-			resolveButton.Enabled = true;
-		}
-		
-		TreeNode MakeTreeNode(AstNode node)
-		{
-			TreeNode t = new TreeNode(GetNodeTitle(node));
-			t.Tag = node;
-			foreach (AstNode child in node.Children) {
-				t.Nodes.Add(MakeTreeNode(child));
-			}
-			return t;
-		}
-		
-		string GetNodeTitle(AstNode node)
-		{
-			StringBuilder b = new StringBuilder();
-			b.Append(node.Role.ToString());
-			b.Append(": ");
-			b.Append(node.GetType().Name);
-			bool hasProperties = false;
-			foreach (PropertyInfo p in node.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
-				if (p.Name == "NodeType" || p.Name == "IsNull")
-					continue;
-				if (p.PropertyType == typeof(string) || p.PropertyType.IsEnum || p.PropertyType == typeof(bool)) {
-					if (!hasProperties) {
-						hasProperties = true;
-						b.Append(" (");
-					} else {
-						b.Append(", ");
-					}
-					b.Append(p.Name);
-					b.Append(" = ");
-					try {
-						object val = p.GetValue(node, null);
-						b.Append(val != null ? val.ToString() : "**null**");
-					} catch (TargetInvocationException ex) {
-						b.Append("**" + ex.InnerException.GetType().Name + "**");
-					}
-				}
-			}
-			if (hasProperties)
-				b.Append(")");
-			return b.ToString();
-		}
-		
-		bool SelectCurrentNode(TreeNodeCollection c)
-		{
-			int selectionStart = csharpCodeTextBox.SelectionStart;
-			int selectionEnd = selectionStart + csharpCodeTextBox.SelectionLength;
-			foreach (TreeNode t in c) {
-				AstNode node = t.Tag as AstNode;
-				if (node != null
-				    && selectionStart >= GetOffset(csharpCodeTextBox, node.StartLocation)
-				    && selectionEnd <= GetOffset(csharpCodeTextBox, node.EndLocation))
-				{
-					if (selectionStart == selectionEnd
-					    && (selectionStart == GetOffset(csharpCodeTextBox, node.StartLocation)
-					        || selectionStart == GetOffset(csharpCodeTextBox, node.EndLocation)))
-					{
-						// caret is on border of this node; don't expand
-						csharpTreeView.SelectedNode = t;
-					} else {
-						t.Expand();
-						if (!SelectCurrentNode(t.Nodes))
-							csharpTreeView.SelectedNode = t;
-					}
-					return true;
-				}
-			}
-			return false;
-		}
-		
-		void CSharpGenerateCodeButtonClick(object sender, EventArgs e)
-		{
-			StringWriter w = new StringWriter();
-			OutputVisitor output = new OutputVisitor(w, new CSharpFormattingOptions());
-			compilationUnit.AcceptVisitor(output, null);
-			csharpCodeTextBox.Text = w.ToString();
-		}
-		
-		int GetOffset(TextBox textBox, AstLocation location)
-		{
-			return textBox.GetFirstCharIndexFromLine(location.Line - 1) + location.Column - 1;
-		}
-		
-		void CSharpTreeViewAfterSelect(object sender, TreeViewEventArgs e)
-		{
-			AstNode node = e.Node.Tag as AstNode;
-			if (node != null) {
-				int startOffset = GetOffset(csharpCodeTextBox, node.StartLocation);
-				int endOffset = GetOffset(csharpCodeTextBox, node.EndLocation);
-				csharpCodeTextBox.Select(startOffset, endOffset - startOffset);
-			}
-		}
-		
-		Lazy<IList<IProjectContent>> builtInLibs = new Lazy<IList<IProjectContent>>(
-			delegate {
-				Assembly[] assemblies = {
-					typeof(object).Assembly, // mscorlib
-					typeof(Uri).Assembly, // System.dll
-					typeof(System.Linq.Enumerable).Assembly, // System.Core.dll
-//					typeof(System.Xml.XmlDocument).Assembly, // System.Xml.dll
-//					typeof(System.Drawing.Bitmap).Assembly, // System.Drawing.dll
-//					typeof(Form).Assembly, // System.Windows.Forms.dll
-					typeof(ICSharpCode.NRefactory.TypeSystem.IProjectContent).Assembly,
-				};
-				IProjectContent[] projectContents = new IProjectContent[assemblies.Length];
-				Stopwatch total = Stopwatch.StartNew();
-				Parallel.For(
-					0, assemblies.Length,
-					delegate (int i) {
-						Stopwatch w = Stopwatch.StartNew();
-						CecilLoader loader = new CecilLoader();
-						projectContents[i] = loader.LoadAssemblyFile(assemblies[i].Location);
-						Debug.WriteLine(Path.GetFileName(assemblies[i].Location) + ": " + w.Elapsed);
-					});
-				Debug.WriteLine("Total: " + total.Elapsed);
-				return projectContents;
-			});
-		
-		void ResolveButtonClick(object sender, EventArgs e)
-		{
-			SimpleProjectContent project = new SimpleProjectContent();
-			TypeSystemConvertVisitor convertVisitor = new TypeSystemConvertVisitor(project, "dummy.cs");
-			compilationUnit.AcceptVisitor(convertVisitor, null);
-			project.UpdateProjectContent(null, convertVisitor.ParsedFile.TopLevelTypeDefinitions, null, null);
-			
-			List<ITypeResolveContext> projects = new List<ITypeResolveContext>();
-			projects.Add(project);
-			projects.AddRange(builtInLibs.Value);
-			
-			using (var context = new CompositeTypeResolveContext(projects).Synchronize()) {
-				CSharpResolver resolver = new CSharpResolver(context);
-				
-				IResolveVisitorNavigator navigator = null;
-				if (csharpTreeView.SelectedNode != null) {
-					navigator = new NodeListResolveVisitorNavigator(new[] { (AstNode)csharpTreeView.SelectedNode.Tag });
-				}
-				ResolveVisitor visitor = new ResolveVisitor(resolver, convertVisitor.ParsedFile, navigator);
-				visitor.Scan(compilationUnit);
-				csharpTreeView.BeginUpdate();
-				ShowResolveResultsInTree(csharpTreeView.Nodes, visitor);
-				csharpTreeView.EndUpdate();
-			}
-		}
-		
-		void ShowResolveResultsInTree(TreeNodeCollection c, ResolveVisitor v)
-		{
-			foreach (TreeNode t in c) {
-				AstNode node = t.Tag as AstNode;
-				if (node != null) {
-					ResolveResult rr = v.GetResolveResult(node);
-					if (rr != null)
-						t.Text = GetNodeTitle(node) + " " + rr.ToString();
-					else
-						t.Text = GetNodeTitle(node);
-				}
-				ShowResolveResultsInTree(t.Nodes, v);
-			}
-		}
-		
-		void CSharpCodeTextBoxKeyDown(object sender, KeyEventArgs e)
-		{
-			if (e.Control && e.KeyCode == Keys.A) {
-				e.Handled = true;
-				csharpCodeTextBox.SelectAll();
-			}
-		}
-		
-		void CsharpCodeTextBoxTextChanged(object sender, EventArgs e)
-		{
-			resolveButton.Enabled = false;
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/VBAstView.cs b/NRefactory/ICSharpCode.NRefactory.Demo/VBAstView.cs
index 42be32e73..a6e6f58aa 100644
--- a/NRefactory/ICSharpCode.NRefactory.Demo/VBAstView.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/VBAstView.cs
@@ -39,89 +39,89 @@ namespace ICSharpCode.NRefactory.Demo
 			InitializeComponent();
 		}
 		
-		public void DeleteSelectedNode()
-		{
-			if (tree.SelectedNode is ElementNode) {
-				INode element = (tree.SelectedNode as ElementNode).element;
-				if (tree.SelectedNode.Parent is CollectionNode) {
-					if (MessageBox.Show("Remove selected node from parent collection?", "Remove node", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
-					    == DialogResult.Yes)
-					{
-						IList col = (tree.SelectedNode.Parent as CollectionNode).collection;
-						col.Remove(element);
-						(tree.SelectedNode.Parent as CollectionNode).Update();
-					}
-				} else if (tree.SelectedNode.Parent is ElementNode) {
-					if (MessageBox.Show("Set selected property to null?", "Remove node", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
-					    == DialogResult.Yes)
-					{
-						// get parent element
-						element = (tree.SelectedNode.Parent as ElementNode).element;
-						string propertyName = (string)tree.SelectedNode.Tag;
-						element.GetType().GetProperty(propertyName).SetValue(element, null, null);
-						(tree.SelectedNode.Parent as ElementNode).Update();
-					}
-				}
-			} else if (tree.SelectedNode is CollectionNode) {
-				if (MessageBox.Show("Remove all elements from selected collection?", "Clear collection", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
-				    == DialogResult.Yes)
-				{
-					IList col = (tree.SelectedNode as CollectionNode).collection;
-					col.Clear();
-					(tree.SelectedNode as CollectionNode).Update();
-				}
-			}
-		}
-		
-		public void EditSelectedNode()
-		{
-			TreeNode node = tree.SelectedNode;
-			while (!(node is ElementNode)) {
-				if (node == null) {
-					return;
-				}
-				node = node.Parent;
-			}
-			INode element = ((ElementNode)node).element;
-			using (VBEditDialog dlg = new VBEditDialog(element)) {
-				dlg.ShowDialog();
-			}
-			((ElementNode)node).Update();
-		}
-		
-		public void ApplyTransformation(IAstVisitor visitor)
-		{
-			if (tree.SelectedNode == tree.Nodes[0]) {
-				unit.AcceptVisitor(visitor, null);
-				UpdateTree();
-			} else {
-				string name = visitor.GetType().Name;
-				ElementNode elementNode = tree.SelectedNode as ElementNode;
-				CollectionNode collectionNode = tree.SelectedNode as CollectionNode;
-				if (elementNode != null) {
-					if (MessageBox.Show(("Apply " + name + " to selected element '" + elementNode.Text + "'?"),
-					                    "Apply transformation", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
-					    == DialogResult.Yes)
-					{
-						elementNode.element.AcceptVisitor(visitor, null);
-						elementNode.Update();
-					}
-				} else if (collectionNode != null) {
-					if (MessageBox.Show(("Apply " + name + " to all elements in selected collection '" + collectionNode.Text + "'?"),
-					                    "Apply transformation", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
-					    == DialogResult.Yes)
-					{
-						foreach (TreeNode subNode in collectionNode.Nodes) {
-							if (subNode is ElementNode) {
-								(subNode as ElementNode).element.AcceptVisitor(visitor, null);
-							}
-						}
-						collectionNode.Update();
-					}
-				}
-			}
-		}
-		
+//		public void DeleteSelectedNode()
+//		{
+//			if (tree.SelectedNode is ElementNode) {
+//				INode element = (tree.SelectedNode as ElementNode).element;
+//				if (tree.SelectedNode.Parent is CollectionNode) {
+//					if (MessageBox.Show("Remove selected node from parent collection?", "Remove node", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
+//					    == DialogResult.Yes)
+//					{
+//						IList col = (tree.SelectedNode.Parent as CollectionNode).collection;
+//						col.Remove(element);
+//						(tree.SelectedNode.Parent as CollectionNode).Update();
+//					}
+//				} else if (tree.SelectedNode.Parent is ElementNode) {
+//					if (MessageBox.Show("Set selected property to null?", "Remove node", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
+//					    == DialogResult.Yes)
+//					{
+//						// get parent element
+//						element = (tree.SelectedNode.Parent as ElementNode).element;
+//						string propertyName = (string)tree.SelectedNode.Tag;
+//						element.GetType().GetProperty(propertyName).SetValue(element, null, null);
+//						(tree.SelectedNode.Parent as ElementNode).Update();
+//					}
+//				}
+//			} else if (tree.SelectedNode is CollectionNode) {
+//				if (MessageBox.Show("Remove all elements from selected collection?", "Clear collection", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
+//				    == DialogResult.Yes)
+//				{
+//					IList col = (tree.SelectedNode as CollectionNode).collection;
+//					col.Clear();
+//					(tree.SelectedNode as CollectionNode).Update();
+//				}
+//			}
+//		}
+//		
+//		public void EditSelectedNode()
+//		{
+//			TreeNode node = tree.SelectedNode;
+//			while (!(node is ElementNode)) {
+//				if (node == null) {
+//					return;
+//				}
+//				node = node.Parent;
+//			}
+//			INode element = ((ElementNode)node).element;
+//			using (VBEditDialog dlg = new VBEditDialog(element)) {
+//				dlg.ShowDialog();
+//			}
+//			((ElementNode)node).Update();
+//		}
+//		
+//		public void ApplyTransformation(IAstVisitor visitor)
+//		{
+//			if (tree.SelectedNode == tree.Nodes[0]) {
+//				unit.AcceptVisitor(visitor, null);
+//				UpdateTree();
+//			} else {
+//				string name = visitor.GetType().Name;
+//				ElementNode elementNode = tree.SelectedNode as ElementNode;
+//				CollectionNode collectionNode = tree.SelectedNode as CollectionNode;
+//				if (elementNode != null) {
+//					if (MessageBox.Show(("Apply " + name + " to selected element '" + elementNode.Text + "'?"),
+//					                    "Apply transformation", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
+//					    == DialogResult.Yes)
+//					{
+//						elementNode.element.AcceptVisitor(visitor, null);
+//						elementNode.Update();
+//					}
+//				} else if (collectionNode != null) {
+//					if (MessageBox.Show(("Apply " + name + " to all elements in selected collection '" + collectionNode.Text + "'?"),
+//					                    "Apply transformation", MessageBoxButtons.YesNo, MessageBoxIcon.Question)
+//					    == DialogResult.Yes)
+//					{
+//						foreach (TreeNode subNode in collectionNode.Nodes) {
+//							if (subNode is ElementNode) {
+//								(subNode as ElementNode).element.AcceptVisitor(visitor, null);
+//							}
+//						}
+//						collectionNode.Update();
+//					}
+//				}
+//			}
+//		}
+//		
 		static TreeNode CreateNode(object child)
 		{
 			if (child == null) {
@@ -164,9 +164,9 @@ namespace ICSharpCode.NRefactory.Demo
 		
 		class ElementNode : TreeNode
 		{
-			internal INode element;
+			internal AstNode element;
 			
-			public ElementNode(INode node)
+			public ElementNode(AstNode node)
 			{
 				this.element = node;
 				Update();
@@ -188,7 +188,7 @@ namespace ICSharpCode.NRefactory.Demo
 				}
 			}
 			
-			void AddProperties(Type type, INode node)
+			void AddProperties(Type type, AstNode node)
 			{
 				if (type == typeof(AbstractNode))
 					return;
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.Designer.cs b/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.Designer.cs
index f4cba1760..48641c669 100644
--- a/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.Designer.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.Designer.cs
@@ -33,11 +33,9 @@ namespace ICSharpCode.NRefactory.Demo
 		{
 			this.splitContainer1 = new System.Windows.Forms.SplitContainer();
 			this.codeView = new System.Windows.Forms.TextBox();
-			this.editNodeButton = new System.Windows.Forms.Button();
-			this.clearSpecialsButton = new System.Windows.Forms.Button();
-			this.syntaxTree = new ICSharpCode.NRefactory.Demo.VBAstView();
 			this.generateCodeButton = new System.Windows.Forms.Button();
 			this.parseButton = new System.Windows.Forms.Button();
+			this.treeView = new System.Windows.Forms.TreeView();
 			((System.ComponentModel.ISupportInitialize)(this.splitContainer1)).BeginInit();
 			this.splitContainer1.Panel1.SuspendLayout();
 			this.splitContainer1.Panel2.SuspendLayout();
@@ -57,11 +55,9 @@ namespace ICSharpCode.NRefactory.Demo
 			// 
 			// splitContainer1.Panel2
 			// 
-			this.splitContainer1.Panel2.Controls.Add(this.editNodeButton);
-			this.splitContainer1.Panel2.Controls.Add(this.clearSpecialsButton);
-			this.splitContainer1.Panel2.Controls.Add(this.syntaxTree);
 			this.splitContainer1.Panel2.Controls.Add(this.generateCodeButton);
 			this.splitContainer1.Panel2.Controls.Add(this.parseButton);
+			this.splitContainer1.Panel2.Controls.Add(this.treeView);
 			this.splitContainer1.Size = new System.Drawing.Size(462, 391);
 			this.splitContainer1.SplitterDistance = 173;
 			this.splitContainer1.TabIndex = 1;
@@ -79,64 +75,41 @@ namespace ICSharpCode.NRefactory.Demo
 			this.codeView.ScrollBars = System.Windows.Forms.ScrollBars.Both;
 			this.codeView.Size = new System.Drawing.Size(462, 173);
 			this.codeView.TabIndex = 0;
-			this.codeView.Text = "Imports System\r\nClass Test\r\n    Public Sub Main(ByVal args As String())\r\n        " +
-			" Console.WriteLine(\"Hello, World\")\r\n    End Sub\r\nEnd Class";
+			this.codeView.Text = "Option Explicit";
 			this.codeView.WordWrap = false;
 			// 
-			// editNodeButton
-			// 
-			this.editNodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.editNodeButton.Location = new System.Drawing.Point(331, 2);
-			this.editNodeButton.Name = "editNodeButton";
-			this.editNodeButton.Size = new System.Drawing.Size(100, 23);
-			this.editNodeButton.TabIndex = 4;
-			this.editNodeButton.Text = "Edit node";
-			this.editNodeButton.UseVisualStyleBackColor = true;
-			this.editNodeButton.Click += new System.EventHandler(this.EditNodeButtonClick);
-			// 
-			// clearSpecialsButton
-			// 
-			this.clearSpecialsButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.clearSpecialsButton.Location = new System.Drawing.Point(225, 2);
-			this.clearSpecialsButton.Name = "clearSpecialsButton";
-			this.clearSpecialsButton.Size = new System.Drawing.Size(100, 23);
-			this.clearSpecialsButton.TabIndex = 3;
-			this.clearSpecialsButton.Text = "Clear 0 specials";
-			this.clearSpecialsButton.UseVisualStyleBackColor = true;
-			this.clearSpecialsButton.Click += new System.EventHandler(this.ClearSpecialsButtonClick);
-			// 
-			// syntaxTree
-			// 
-			this.syntaxTree.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-									| System.Windows.Forms.AnchorStyles.Left) 
-									| System.Windows.Forms.AnchorStyles.Right)));
-			this.syntaxTree.Location = new System.Drawing.Point(3, 32);
-			this.syntaxTree.Name = "syntaxTree";
-			this.syntaxTree.Size = new System.Drawing.Size(459, 182);
-			this.syntaxTree.TabIndex = 2;
-			this.syntaxTree.Unit = null;
-			// 
 			// generateCodeButton
 			// 
 			this.generateCodeButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.generateCodeButton.Location = new System.Drawing.Point(119, 2);
+			this.generateCodeButton.Location = new System.Drawing.Point(225, 2);
 			this.generateCodeButton.Name = "generateCodeButton";
 			this.generateCodeButton.Size = new System.Drawing.Size(100, 23);
 			this.generateCodeButton.TabIndex = 1;
 			this.generateCodeButton.Text = "Generate";
 			this.generateCodeButton.UseVisualStyleBackColor = true;
-			this.generateCodeButton.Click += new System.EventHandler(this.GenerateCodeButtonClick);
+			this.generateCodeButton.Click += new System.EventHandler(this.CSharpGenerateCodeButtonClick);
 			// 
 			// parseButton
 			// 
 			this.parseButton.Anchor = System.Windows.Forms.AnchorStyles.Top;
-			this.parseButton.Location = new System.Drawing.Point(13, 2);
+			this.parseButton.Location = new System.Drawing.Point(119, 2);
 			this.parseButton.Name = "parseButton";
 			this.parseButton.Size = new System.Drawing.Size(100, 23);
 			this.parseButton.TabIndex = 0;
 			this.parseButton.Text = "Parse";
 			this.parseButton.UseVisualStyleBackColor = true;
-			this.parseButton.Click += new System.EventHandler(this.ParseButtonClick);
+			this.parseButton.Click += new System.EventHandler(this.CSharpParseButtonClick);
+			// 
+			// treeView
+			// 
+			this.treeView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
+									| System.Windows.Forms.AnchorStyles.Left) 
+									| System.Windows.Forms.AnchorStyles.Right)));
+			this.treeView.Location = new System.Drawing.Point(3, 31);
+			this.treeView.Name = "treeView";
+			this.treeView.Size = new System.Drawing.Size(459, 180);
+			this.treeView.TabIndex = 0;
+			this.treeView.AfterSelect += new System.Windows.Forms.TreeViewEventHandler(this.CSharpTreeViewAfterSelect);
 			// 
 			// VBDemo
 			// 
@@ -152,10 +125,8 @@ namespace ICSharpCode.NRefactory.Demo
 			this.splitContainer1.ResumeLayout(false);
 			this.ResumeLayout(false);
 		}
-		private System.Windows.Forms.Button clearSpecialsButton;
-		private System.Windows.Forms.Button editNodeButton;
-		private ICSharpCode.NRefactory.Demo.VBAstView syntaxTree;
 		private System.Windows.Forms.TextBox codeView;
+		private System.Windows.Forms.TreeView treeView;
 		private System.Windows.Forms.Button generateCodeButton;
 		private System.Windows.Forms.Button parseButton;
 		private System.Windows.Forms.SplitContainer splitContainer1;
diff --git a/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.cs b/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.cs
index 387921259..beb3308c1 100644
--- a/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Demo/VBDemo.cs
@@ -7,10 +7,13 @@ using System.ComponentModel;
 using System.Drawing;
 using System.IO;
 using System.Linq;
+using System.Reflection;
+using System.Text;
 using System.Windows.Forms;
+
 using ICSharpCode.NRefactory.VB;
+using ICSharpCode.NRefactory.VB.Ast;
 using ICSharpCode.NRefactory.VB.Parser;
-using ICSharpCode.NRefactory.VB.PrettyPrinter;
 
 namespace ICSharpCode.NRefactory.Demo
 {
@@ -25,54 +28,113 @@ namespace ICSharpCode.NRefactory.Demo
 			// The InitializeComponent() call is required for Windows Forms designer support.
 			//
 			InitializeComponent();
-			ParseButtonClick(null, null);
 		}
 		
-		IList<ISpecial> savedSpecials;
+		CompilationUnit compilationUnit;
+		
+		void CSharpParseButtonClick(object sender, EventArgs e)
+		{
+			var parser = new VBParser();
+			compilationUnit = parser.Parse(new StringReader(codeView.Text));
+			if (parser.HasErrors)
+				MessageBox.Show(parser.Errors.ErrorOutput);
+			treeView.Nodes.Clear();
+			foreach (var element in compilationUnit.Children) {
+				treeView.Nodes.Add(MakeTreeNode(element));
+			}
+			SelectCurrentNode(treeView.Nodes);
+		}
+		
+		TreeNode MakeTreeNode(AstNode node)
+		{
+			TreeNode t = new TreeNode(GetNodeTitle(node));
+			t.Tag = node;
+			foreach (AstNode child in node.Children) {
+				t.Nodes.Add(MakeTreeNode(child));
+			}
+			return t;
+		}
 		
-		void ParseButtonClick(object sender, EventArgs e)
+		string GetNodeTitle(AstNode node)
 		{
-			using (VBParser parser = new VBParser(new VBLexer(new StringReader(codeView.Text)))) {
-				parser.Parse();
-				// this allows retrieving comments, preprocessor directives, etc. (stuff that isn't part of the syntax)
-				SetSpecials(parser.Lexer.SpecialTracker.RetrieveSpecials());
-				// this retrieves the root node of the result DOM
-				if (parser.Errors.Count > 0) {
-					MessageBox.Show(parser.Errors.ErrorOutput);
+			StringBuilder b = new StringBuilder();
+			b.Append(node.Role.ToString());
+			b.Append(": ");
+			b.Append(node.GetType().Name);
+			bool hasProperties = false;
+			foreach (PropertyInfo p in node.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance)) {
+				if (p.Name == "NodeType" || p.Name == "IsNull")
+					continue;
+				if (p.PropertyType == typeof(string) || p.PropertyType.IsEnum || p.PropertyType == typeof(bool)) {
+					if (!hasProperties) {
+						hasProperties = true;
+						b.Append(" (");
+					} else {
+						b.Append(", ");
+					}
+					b.Append(p.Name);
+					b.Append(" = ");
+					try {
+						object val = p.GetValue(node, null);
+						b.Append(val != null ? val.ToString() : "**null**");
+					} catch (TargetInvocationException ex) {
+						b.Append("**" + ex.InnerException.GetType().Name + "**");
+					}
 				}
-				syntaxTree.Unit = parser.CompilationUnit;
 			}
+			if (hasProperties)
+				b.Append(")");
+			return b.ToString();
 		}
 		
-		void GenerateCodeButtonClick(object sender, EventArgs e)
+		bool SelectCurrentNode(TreeNodeCollection c)
 		{
-			if (syntaxTree.Unit != null) {
-				VBNetOutputVisitor visitor = new VBNetOutputVisitor();
-				// re-insert the comments we saved from the parser into the output
-				using (SpecialNodesInserter.Install(savedSpecials, visitor)) {
-					syntaxTree.Unit.AcceptVisitor(visitor, null);
+			int selectionStart = codeView.SelectionStart;
+			int selectionEnd = selectionStart + codeView.SelectionLength;
+			foreach (TreeNode t in c) {
+				AstNode node = t.Tag as AstNode;
+				if (node != null
+				    && selectionStart >= GetOffset(codeView, node.StartLocation)
+				    && selectionEnd <= GetOffset(codeView, node.EndLocation))
+				{
+					if (selectionStart == selectionEnd
+					    && (selectionStart == GetOffset(codeView, node.StartLocation)
+					        || selectionStart == GetOffset(codeView, node.EndLocation)))
+					{
+						// caret is on border of this node; don't expand
+						treeView.SelectedNode = t;
+					} else {
+						t.Expand();
+						if (!SelectCurrentNode(t.Nodes))
+							treeView.SelectedNode = t;
+					}
+					return true;
 				}
-				codeView.Text = visitor.Text.Replace("\t", "  ");
 			}
+			return false;
 		}
 		
-		void ClearSpecialsButtonClick(object sender, EventArgs e)
+		void CSharpGenerateCodeButtonClick(object sender, EventArgs e)
 		{
-			SetSpecials(new ISpecial[0]);
+			StringWriter w = new StringWriter();
+			OutputVisitor output = new OutputVisitor(w, new VBFormattingOptions());
+			compilationUnit.AcceptVisitor(output, null);
+			codeView.Text = w.ToString();
 		}
 		
-		void EditNodeButtonClick(object sender, EventArgs e)
+		int GetOffset(TextBox textBox, AstLocation location)
 		{
-			syntaxTree.EditSelectedNode();
+			return textBox.GetFirstCharIndexFromLine(location.Line - 1) + location.Column - 1;
 		}
 		
-		void SetSpecials(IList<ISpecial> specials)
+		void CSharpTreeViewAfterSelect(object sender, TreeViewEventArgs e)
 		{
-			savedSpecials = specials;
-			if (specials.Count == 1)
-				clearSpecialsButton.Text = "Clear 1 special";
-			else
-				clearSpecialsButton.Text = "Clear " + specials.Count + " specials";
+			AstNode node = e.Node.Tag as AstNode;
+			if (node != null) {
+				int startOffset = GetOffset(codeView, node.StartLocation);
+				int endOffset = GetOffset(codeView, node.EndLocation);
+				codeView.Select(startOffset, endOffset - startOffset);
+			}
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConditionalOperatorTests.cs b/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConditionalOperatorTests.cs
new file mode 100644
index 000000000..d1178757e
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.Tests/CSharp/Resolver/ConditionalOperatorTests.cs
@@ -0,0 +1,85 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	// assign short name to the fake reflection type
+	using dynamic = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.Dynamic;
+	
+	[TestFixture]
+	public class ConditionalOperatorTests : ResolverTestBase
+	{
+		[Test]
+		public void PickMoreGeneralOfTheTypes()
+		{
+			AssertType(typeof(object), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(string)), MakeResult(typeof(object))));
+			AssertType(typeof(long), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(int)), MakeResult(typeof(long))));
+		}
+		
+		[Test]
+		public void Null()
+		{
+			AssertType(typeof(string), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(string)), MakeConstant(null)));
+			AssertType(typeof(string), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeConstant(null), MakeResult(typeof(string))));
+		}
+		
+		[Test]
+		public void DynamicInArguments()
+		{
+			AssertType(typeof(dynamic), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(dynamic)), MakeResult(typeof(double))));
+			
+			AssertType(typeof(dynamic), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(double)), MakeResult(typeof(dynamic))));
+		}
+		
+		[Test]
+		public void DynamicInCondition()
+		{
+			AssertType(typeof(double), resolver.ResolveConditional(
+				MakeResult(typeof(dynamic)), MakeResult(typeof(float)), MakeResult(typeof(double))));
+		}
+		
+		[Test]
+		public void AllDynamic()
+		{
+			AssertType(typeof(dynamic), resolver.ResolveConditional(
+				MakeResult(typeof(dynamic)), MakeResult(typeof(dynamic)), MakeResult(typeof(dynamic))));
+		}
+		
+		[Test]
+		public void ListOfDynamicAndListOfObject()
+		{
+			AssertError(typeof(List<dynamic>), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(List<object>)), MakeResult(typeof(List<dynamic>))));
+			
+			AssertError(typeof(List<object>), resolver.ResolveConditional(
+				MakeResult(typeof(bool)), MakeResult(typeof(List<dynamic>)), MakeResult(typeof(List<object>))));
+		}
+		
+		[Test]
+		public void Constant()
+		{
+			AssertConstant(1L, resolver.ResolveConditional(
+				MakeConstant(true), MakeConstant(1), MakeConstant(2L)));
+			
+			AssertConstant(2L, resolver.ResolveConditional(
+				MakeConstant(false), MakeConstant(1), MakeConstant(2L)));
+		}
+		
+		[Test]
+		public void NotConstantIfFalsePortionNotConstant()
+		{
+			AssertType(typeof(long), resolver.ResolveConditional(
+				MakeConstant(true), MakeConstant(1), MakeResult(typeof(long))));
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj b/NRefactory/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj
index b8b338bbe..cebee2aa5 100644
--- a/NRefactory/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj
+++ b/NRefactory/ICSharpCode.NRefactory.Tests/ICSharpCode.NRefactory.Tests.csproj
@@ -120,6 +120,7 @@
     <Compile Include="CSharp\Resolver\AttributeTests.cs" />
     <Compile Include="CSharp\Resolver\BinaryOperatorTests.cs" />
     <Compile Include="CSharp\Resolver\CastTests.cs" />
+    <Compile Include="CSharp\Resolver\ConditionalOperatorTests.cs" />
     <Compile Include="CSharp\Resolver\ExtensionMethodTests.cs" />
     <Compile Include="CSharp\Resolver\InvocationTests.cs" />
     <Compile Include="CSharp\Resolver\LambdaTests.cs" />
@@ -143,6 +144,7 @@
     <Compile Include="TypeSystem\GetAllBaseTypesTest.cs" />
     <Compile Include="TypeSystem\GetMembersTests.cs" />
     <Compile Include="TypeSystem\ReflectionHelperTests.cs" />
+    <Compile Include="TypeSystem\StructureTests.cs" />
     <Compile Include="TypeSystem\TestInterningProvider.cs" />
     <Compile Include="TypeSystem\TypeSystemTests.cs" />
     <Compile Include="TypeSystem\TypeSystemTests.TestCase.cs" />
diff --git a/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/StructureTests.cs b/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/StructureTests.cs
new file mode 100644
index 000000000..f4931bc33
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/StructureTests.cs
@@ -0,0 +1,22 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.TypeSystem
+{
+	[TestFixture]
+	public class StructureTests
+	{
+		[Test]
+		public void ClasesThatSupportInterningAreSealed()
+		{
+			foreach (Type type in typeof(ISupportsInterning).Assembly.GetTypes()) {
+				if (typeof(ISupportsInterning).IsAssignableFrom(type) && !type.IsInterface) {
+					Assert.IsTrue(type.IsSealed, type.FullName);
+				}
+			}
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TestInterningProvider.cs b/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TestInterningProvider.cs
index 8df59cf46..e3ebea8fc 100644
--- a/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TestInterningProvider.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TestInterningProvider.cs
@@ -15,7 +15,7 @@ using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.TypeSystem
 {
-	//* Not a real unit test
+	/* Not a real unit test
 	[TestFixture]
 	public class TestInterningProvider
 	{
diff --git a/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs b/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs
index 6432046df..bd2a786a1 100644
--- a/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.Tests/TypeSystem/TypeSystemTests.cs
@@ -114,16 +114,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			var attributes = testCasePC.AssemblyAttributes;
 			var typeTest = attributes.First(a => a.AttributeType.Resolve(ctx).FullName == typeof(TypeTestAttribute).FullName);
-			Assert.AreEqual(3, typeTest.PositionalArguments.Count);
+			var posArgs = typeTest.GetPositionalArguments(ctx);
+			Assert.AreEqual(3, posArgs.Count);
 			// first argument is (int)42
-			Assert.AreEqual(42, (int)typeTest.PositionalArguments[0].GetValue(ctx));
+			Assert.AreEqual(42, (int)posArgs[0].GetValue(ctx));
 			// second argument is typeof(System.Action<>)
-			IType rt = (IType)typeTest.PositionalArguments[1].GetValue(ctx);
+			IType rt = (IType)posArgs[1].GetValue(ctx);
 			Assert.IsFalse(rt is ParameterizedType); // rt must not be constructed - it's just an unbound type
 			Assert.AreEqual("System.Action", rt.FullName);
 			Assert.AreEqual(1, rt.TypeParameterCount);
 			// third argument is typeof(IDictionary<string, IList<TestAttribute>>)
-			ParameterizedType crt = (ParameterizedType)typeTest.PositionalArguments[2].GetValue(ctx);
+			ParameterizedType crt = (ParameterizedType)posArgs[2].GetValue(ctx);
 			Assert.AreEqual("System.Collections.Generic.IDictionary", crt.FullName);
 			Assert.AreEqual("System.String", crt.TypeArguments[0].FullName);
 			// ? for NUnit.TestAttribute (because that assembly isn't in ctx)
@@ -282,16 +283,17 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			IAttribute attr = ctx.GetClass(typeof(ExplicitFieldLayoutStruct)).Attributes.Single();
 			Assert.AreEqual("System.Runtime.InteropServices.StructLayoutAttribute", attr.AttributeType.Resolve(ctx).FullName);
-			IConstantValue arg1 = attr.PositionalArguments.Single();
+			IConstantValue arg1 = attr.GetPositionalArguments(ctx).Single();
 			Assert.AreEqual("System.Runtime.InteropServices.LayoutKind", arg1.GetValueType(ctx).FullName);
 			Assert.AreEqual((int)LayoutKind.Explicit, arg1.GetValue(ctx));
 			
-			var arg2 = attr.NamedArguments[0];
+			var namedArgs = attr.GetNamedArguments(ctx);
+			var arg2 = namedArgs[0];
 			Assert.AreEqual("CharSet", arg2.Key);
 			Assert.AreEqual("System.Runtime.InteropServices.CharSet", arg2.Value.GetValueType(ctx).FullName);
 			Assert.AreEqual((int)CharSet.Unicode, arg2.Value.GetValue(ctx));
 			
-			var arg3 = attr.NamedArguments[1];
+			var arg3 = namedArgs[1];
 			Assert.AreEqual("Pack", arg3.Key);
 			Assert.AreEqual("System.Int32", arg3.Value.GetValueType(ctx).FullName);
 			Assert.AreEqual(8, arg3.Value.GetValue(ctx));
@@ -302,13 +304,13 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			IField field = ctx.GetClass(typeof(ExplicitFieldLayoutStruct)).Fields.Single(f => f.Name == "Field0");
 			Assert.AreEqual("System.Runtime.InteropServices.FieldOffsetAttribute", field.Attributes.Single().AttributeType.Resolve(ctx).FullName);
-			IConstantValue arg = field.Attributes.Single().PositionalArguments.Single();
+			IConstantValue arg = field.Attributes.Single().GetPositionalArguments(ctx).Single();
 			Assert.AreEqual("System.Int32", arg.GetValueType(ctx).FullName);
 			Assert.AreEqual(0, arg.GetValue(ctx));
 			
 			field = ctx.GetClass(typeof(ExplicitFieldLayoutStruct)).Fields.Single(f => f.Name == "Field100");
 			Assert.AreEqual("System.Runtime.InteropServices.FieldOffsetAttribute", field.Attributes.Single().AttributeType.Resolve(ctx).FullName);
-			arg = field.Attributes.Single().PositionalArguments.Single();
+			arg = field.Attributes.Single().GetPositionalArguments(ctx).Single();
 			Assert.AreEqual("System.Int32", arg.GetValueType(ctx).FullName);
 			Assert.AreEqual(100, arg.GetValue(ctx));
 		}
@@ -319,8 +321,8 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			IMethod method = ctx.GetClass(typeof(NonCustomAttributes)).Methods.Single(m => m.Name == "DllMethod");
 			IAttribute dllImport = method.Attributes.Single();
 			Assert.AreEqual("System.Runtime.InteropServices.DllImportAttribute", dllImport.AttributeType.Resolve(ctx).FullName);
-			Assert.AreEqual("unmanaged.dll", dllImport.PositionalArguments[0].GetValue(ctx));
-			Assert.AreEqual((int)CharSet.Unicode, dllImport.NamedArguments.Single().Value.GetValue(ctx));
+			Assert.AreEqual("unmanaged.dll", dllImport.GetPositionalArguments(ctx)[0].GetValue(ctx));
+			Assert.AreEqual((int)CharSet.Unicode, dllImport.GetNamedArguments(ctx).Single().Value.GetValue(ctx));
 		}
 		
 		[Test]
@@ -339,7 +341,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		{
 			IMethod method = ctx.GetClass(typeof(NonCustomAttributes)).Methods.Single(m => m.Name == "DllMethod");
 			IAttribute marshalAs = method.ReturnTypeAttributes.Single();
-			Assert.AreEqual((int)UnmanagedType.Bool, marshalAs.PositionalArguments.Single().GetValue(ctx));
+			Assert.AreEqual((int)UnmanagedType.Bool, marshalAs.GetPositionalArguments(ctx).Single().GetValue(ctx));
 		}
 		
 		[Test]
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs
index 2db6aa293..def7d7d0f 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/General/UnitTest.cs
@@ -6,44 +6,43 @@ using System.Reflection;
 using NUnit.Framework;
 using ICSharpCode.NRefactory.VB.Ast;
 using ICSharpCode.NRefactory.VB.Parser;
-using ICSharpCode.NRefactory.VB.Visitors;
 
 namespace ICSharpCode.NRefactory.VB.Tests
 {
 	[TestFixture]
 	public class StructuralTest
 	{
-		[Test]
-		public void TestToStringMethods()
-		{
-			Type[] allTypes = typeof(INode).Assembly.GetTypes();
-			
-			foreach (Type type in allTypes) {
-				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null) {
-					MethodInfo methodInfo = type.GetMethod("ToString", BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public);
-					Assert.IsNotNull(methodInfo, "ToString() not found in " + type.FullName);
-				}
-			}
-		}
-		
-		[Test]
-		public void TestUnitTests()
-		{
-			Type[] allTypes = typeof(StructuralTest).Assembly.GetTypes();
-			
-			foreach (Type type in allTypes) {
-				if (type.GetCustomAttributes(typeof(TestFixtureAttribute), true).Length > 0) {
-					foreach (MethodInfo m in type.GetMethods()) {
-						if (m.IsPublic && m.ReturnType == typeof(void) && m.GetParameters().Length == 0) {
-							if (m.GetCustomAttributes(typeof(TestAttribute), true).Length == 0) {
-								Assert.Fail(type.Name + "." + m.Name + " should have the [Test] attribute!");
-							}
-						}
-					}
-				}
-			}
-		}
-		
+//		[Test]
+//		public void TestToStringMethods()
+//		{
+//			Type[] allTypes = typeof(INode).Assembly.GetTypes();
+//			
+//			foreach (Type type in allTypes) {
+//				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null) {
+//					MethodInfo methodInfo = type.GetMethod("ToString", BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public);
+//					Assert.IsNotNull(methodInfo, "ToString() not found in " + type.FullName);
+//				}
+//			}
+//		}
+//		
+//		[Test]
+//		public void TestUnitTests()
+//		{
+//			Type[] allTypes = typeof(StructuralTest).Assembly.GetTypes();
+//			
+//			foreach (Type type in allTypes) {
+//				if (type.GetCustomAttributes(typeof(TestFixtureAttribute), true).Length > 0) {
+//					foreach (MethodInfo m in type.GetMethods()) {
+//						if (m.IsPublic && m.ReturnType == typeof(void) && m.GetParameters().Length == 0) {
+//							if (m.GetCustomAttributes(typeof(TestAttribute), true).Length == 0) {
+//								Assert.Fail(type.Name + "." + m.Name + " should have the [Test] attribute!");
+//							}
+//						}
+//					}
+//				}
+//			}
+//		}
+//		
 //		[Test]
 //		public void TestAcceptVisitorMethods()
 //		{
@@ -56,48 +55,48 @@ namespace ICSharpCode.NRefactory.VB.Tests
 //				}
 //			}
 //		}
-		
-		[Test]
-		public void TestIAstVisitor()
-		{
-			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
-			Type visitor = typeof(IAstVisitor);
-			
-			foreach (Type type in allTypes) {
-				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
-					MethodInfo methodInfo = visitor.GetMethod("Visit" + type.Name, BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] {type, typeof(object)}, null);
-					Assert.IsNotNull(methodInfo, "Visit with parameter " + type.FullName + " not found");
-					Assert.AreEqual(2, methodInfo.GetParameters().Length);
-					ParameterInfo first = methodInfo.GetParameters()[0];
-					Assert.AreEqual(Char.ToLower(first.ParameterType.Name[0]) + first.ParameterType.Name.Substring(1), first.Name);
-					
-					ParameterInfo second = methodInfo.GetParameters()[1];
-					Assert.AreEqual(typeof(System.Object), second.ParameterType);
-					Assert.AreEqual("data", second.Name);
-				}
-			}
-		}
-		
-		[Test]
-		public void TestAbstractAstVisitorVisitor()
-		{
-			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
-			Type visitor = typeof(AbstractAstVisitor);
-			
-			foreach (Type type in allTypes) {
-				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
-					MethodInfo methodInfo = visitor.GetMethod("Visit" + type.Name, BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] {type, typeof(object)}, null);
-					Assert.IsNotNull(methodInfo, "Visit with parameter " + type.FullName + " not found");
-					
-					Assert.AreEqual(2, methodInfo.GetParameters().Length);
-					ParameterInfo first = methodInfo.GetParameters()[0];
-					Assert.AreEqual(Char.ToLower(first.ParameterType.Name[0]) + first.ParameterType.Name.Substring(1), first.Name);
-					
-					ParameterInfo second = methodInfo.GetParameters()[1];
-					Assert.AreEqual(typeof(System.Object), second.ParameterType);
-					Assert.AreEqual("data", second.Name);
-				}
-			}
-		}
+//		
+//		[Test]
+//		public void TestIAstVisitor()
+//		{
+//			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
+//			Type visitor = typeof(IAstVisitor);
+//			
+//			foreach (Type type in allTypes) {
+//				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
+//					MethodInfo methodInfo = visitor.GetMethod("Visit" + type.Name, BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] {type, typeof(object)}, null);
+//					Assert.IsNotNull(methodInfo, "Visit with parameter " + type.FullName + " not found");
+//					Assert.AreEqual(2, methodInfo.GetParameters().Length);
+//					ParameterInfo first = methodInfo.GetParameters()[0];
+//					Assert.AreEqual(Char.ToLower(first.ParameterType.Name[0]) + first.ParameterType.Name.Substring(1), first.Name);
+//					
+//					ParameterInfo second = methodInfo.GetParameters()[1];
+//					Assert.AreEqual(typeof(System.Object), second.ParameterType);
+//					Assert.AreEqual("data", second.Name);
+//				}
+//			}
+//		}
+//		
+//		[Test]
+//		public void TestAbstractAstVisitorVisitor()
+//		{
+//			Type[] allTypes = typeof(AbstractNode).Assembly.GetTypes();
+//			Type visitor = typeof(AbstractAstVisitor);
+//			
+//			foreach (Type type in allTypes) {
+//				if (type.IsClass && !type.IsAbstract && !type.IsNested && type.GetInterface(typeof(INode).FullName) != null && !type.Name.StartsWith("Null")) {
+//					MethodInfo methodInfo = visitor.GetMethod("Visit" + type.Name, BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.ExactBinding, null, new Type[] {type, typeof(object)}, null);
+//					Assert.IsNotNull(methodInfo, "Visit with parameter " + type.FullName + " not found");
+//					
+//					Assert.AreEqual(2, methodInfo.GetParameters().Length);
+//					ParameterInfo first = methodInfo.GetParameters()[0];
+//					Assert.AreEqual(Char.ToLower(first.ParameterType.Name[0]) + first.ParameterType.Name.Substring(1), first.Name);
+//					
+//					ParameterInfo second = methodInfo.GetParameters()[1];
+//					Assert.AreEqual(typeof(System.Object), second.ParameterType);
+//					Assert.AreEqual("data", second.Name);
+//				}
+//			}
+//		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/ICSharpCode.NRefactory.VB.Tests.csproj b/NRefactory/ICSharpCode.NRefactory.VB.Tests/ICSharpCode.NRefactory.VB.Tests.csproj
index fef832cb3..f0da0835c 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/ICSharpCode.NRefactory.VB.Tests.csproj
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/ICSharpCode.NRefactory.VB.Tests.csproj
@@ -66,90 +66,23 @@
     <Compile Include="Lexer\LiteralsTests.cs" />
     <Compile Include="Lexer\TokenTests.cs" />
     <Compile Include="Lexer\XmlModeLexerTests.cs" />
-    <Compile Include="Output\CodeDOM\CodeDOMTypeReferenceTest.cs" />
-    <Compile Include="Parser\CheckParentVisitor.cs" />
-    <Compile Include="Parser\Expressions\AddressOfExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\LambdaExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\QueryExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\XmlExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\XmlMemberAccessExpressionTests.cs" />
     <Compile Include="Parser\GlobalScope\AttributeSectionTests.cs" />
-    <Compile Include="Parser\Expressions\PrimitiveExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\ParenthesizedExpressionTest.cs" />
-    <Compile Include="Parser\Expressions\ThisReferenceExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\BaseReferenceExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\IdentifierExpressionTests.cs" />
     <Compile Include="Parser\GlobalScope\NamespaceDeclarationTests.cs" />
-    <Compile Include="Parser\Expressions\AssignmentExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\BinaryOperatorExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\UnaryOperatorExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\CastExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\MemberReferenceExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\InvocationExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\TypeOfExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\ArrayCreateExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\ObjectCreateExpressionTests.cs" />
-    <Compile Include="Parser\GlobalScope\DelegateDeclarationTests.cs" />
-    <Compile Include="Parser\Expressions\ConditionalExpressionTests.cs" />
-    <Compile Include="Parser\GlobalScope\UsingDeclarationTests.cs" />
+    <Compile Include="Parser\GlobalScope\ImportsStatementTests.cs" />
     <Compile Include="Parser\GlobalScope\TypeDeclarationTests.cs" />
-    <Compile Include="Parser\LocationAssignmentCheckVisitor.cs" />
     <Compile Include="Parser\SnippetParserTests.cs" />
-    <Compile Include="Parser\TypeLevel\ConstructorDeclarationTests.cs" />
-    <Compile Include="Parser\TypeLevel\EventDeclarationTests.cs" />
-    <Compile Include="Parser\TypeLevel\FieldDeclarationTests.cs" />
-    <Compile Include="Parser\TypeLevel\MethodDeclarationTests.cs" />
-    <Compile Include="Parser\TypeLevel\PropertyDeclarationTests.cs" />
-    <Compile Include="Parser\TypeLevel\OperatorDeclarationTests.cs" />
-    <Compile Include="Parser\Statements\BlockStatementTests.cs" />
-    <Compile Include="Parser\Statements\ContinueStatementTests.cs" />
-    <Compile Include="Parser\Statements\DoLoopStatementTests.cs" />
-    <Compile Include="Parser\Statements\ForeachStatementTests.cs" />
-    <Compile Include="Parser\Statements\GotoStatementTests.cs" />
-    <Compile Include="Parser\Statements\IfElseStatementTests.cs" />
-    <Compile Include="Parser\Statements\LabelStatementTests.cs" />
-    <Compile Include="Parser\Statements\LocalVariableDeclarationTests.cs" />
-    <Compile Include="Parser\Statements\LockStatementTests.cs" />
-    <Compile Include="Parser\Statements\ReturnStatementTests.cs" />
-    <Compile Include="Parser\Statements\ExpressionStatementTests.cs" />
-    <Compile Include="Parser\Statements\SwitchStatementTests.cs" />
-    <Compile Include="Parser\Statements\ThrowStatementTests.cs" />
-    <Compile Include="Parser\Statements\TryCatchStatementTests.cs" />
-    <Compile Include="Parser\Statements\UsingStatementTests.cs" />
-    <Compile Include="Parser\Expressions\ClassReferenceExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\TypeOfIsExpressionTests.cs" />
     <Compile Include="Parser\ParseUtil.cs" />
-    <Compile Include="Parser\GlobalScope\OptionDeclarationTests.cs" />
-    <Compile Include="Parser\TypeLevel\DeclareDeclarationTests.cs" />
-    <Compile Include="Parser\Statements\AddHandlerStatementTests.cs" />
-    <Compile Include="Parser\Statements\EndStatementTests.cs" />
-    <Compile Include="Parser\Statements\EraseStatementTests.cs" />
-    <Compile Include="Parser\Statements\ErrorStatementTests.cs" />
-    <Compile Include="Parser\Statements\ForNextStatementTests.cs" />
-    <Compile Include="Parser\Statements\OnErrorStatementTest.cs" />
-    <Compile Include="Parser\Statements\RaiseEventStatementTest.cs" />
-    <Compile Include="Parser\Statements\ReDimStatementTests.cs" />
-    <Compile Include="Parser\Statements\RemoveHandlerStatement.cs" />
-    <Compile Include="Parser\Statements\ResumeStatement.cs" />
-    <Compile Include="Parser\Statements\StopStatementTests.cs" />
-    <Compile Include="Parser\Statements\WithStatementTests.cs" />
-    <Compile Include="Output\CodeDOM\CodeDOMPrimitiveExpressionTest.cs" />
-    <Compile Include="Output\CodeDOM\CodeDOMParenthesizedExpressionTest.cs" />
-    <Compile Include="Output\CodeDOM\InvocationExpressionTest.cs" />
-    <Compile Include="Parser\Expressions\TypeReferenceExpressionTests.cs" />
-    <Compile Include="Parser\Expressions\GlobalReferenceExpressionTests.cs" />
-    <Compile Include="Parser\TypeLevel\CustomEventTests.cs" />
-    <Compile Include="Output\VBNet\VBNetOutputTest.cs" />
-    <Compile Include="Output\SpecialOutputVisitorTest.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Output\VBNet" />
+    <Compile Include="Parser\GlobalScope\OptionStatementTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ICSharpCode.NRefactory.VB\ICSharpCode.NRefactory.VB.csproj">
       <Project>{7B82B671-419F-45F4-B778-D9286F996EFA}</Project>
       <Name>ICSharpCode.NRefactory.VB</Name>
     </ProjectReference>
+    <ProjectReference Include="..\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj">
+      <Project>{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}</Project>
+      <Name>ICSharpCode.NRefactory</Name>
+    </ProjectReference>
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSHARP.Targets" />
 </Project>
\ No newline at end of file
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs
index ce697d143..c37cf1b02 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/CustomLexerTests.cs
@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	{
 		VBLexer GenerateLexer(StringReader sr)
 		{
-			return ParserFactory.CreateLexer(sr);
+			return new VBLexer(sr);
 		}
 		
 		[Test]
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs
index 0c24c847f..8e5bcdb71 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/ImplicitLineContinuationTests.cs
@@ -213,7 +213,7 @@ End Class";
 		#region Helpers
 		VBLexer GenerateLexer(StringReader sr)
 		{
-			return ParserFactory.CreateLexer(sr);
+			return new VBLexer(sr);
 		}
 		
 		void CheckTokens(VBLexer lexer, params int[] tokens)
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs
index 174a96343..f04ab8469 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerContextTests.cs
@@ -556,7 +556,7 @@ exit Global
 		void RunTest(string code, string expectedOutput)
 		{
 			ExpressionFinder p = new ExpressionFinder();
-			VBLexer lexer = ParserFactory.CreateLexer(new StringReader(code));
+			VBLexer lexer = new VBLexer(new StringReader(code));
 			Token t;
 			
 			do {
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs
index f227c5c8a..553ba27a6 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerPositionTests.cs
@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	{
 		VBLexer GenerateLexer(string s)
 		{
-			return ParserFactory.CreateLexer(new StringReader(s));
+			return new VBLexer(new StringReader(s));
 		}
 		
 		[Test]
@@ -22,16 +22,16 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 			VBLexer l = GenerateLexer("public\nstatic");
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.Public, t.Kind);
-			Assert.AreEqual(new Location(1, 1), t.Location);
-			Assert.AreEqual(new Location(7, 1), t.EndLocation);
+			Assert.AreEqual(new AstLocation(1, 1), t.Location);
+			Assert.AreEqual(new AstLocation(7, 1), t.EndLocation);
 			t = l.NextToken();
 			Assert.AreEqual(Tokens.EOL, t.Kind);
-			Assert.AreEqual(new Location(7, 1), t.Location);
-			Assert.AreEqual(new Location(1, 2), t.EndLocation);
+			Assert.AreEqual(new AstLocation(7, 1), t.Location);
+			Assert.AreEqual(new AstLocation(1, 2), t.EndLocation);
 			t = l.NextToken();
 			Assert.AreEqual(Tokens.Static, t.Kind);
-			Assert.AreEqual(new Location(1, 2), t.Location);
-			Assert.AreEqual(new Location(7, 2), t.EndLocation);
+			Assert.AreEqual(new AstLocation(1, 2), t.Location);
+			Assert.AreEqual(new AstLocation(7, 2), t.EndLocation);
 		}
 		
 		[Test]
@@ -40,16 +40,16 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 			VBLexer l = GenerateLexer("public\r\nstatic");
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.Public, t.Kind);
-			Assert.AreEqual(new Location(1, 1), t.Location);
-			Assert.AreEqual(new Location(7, 1), t.EndLocation);
+			Assert.AreEqual(new AstLocation(1, 1), t.Location);
+			Assert.AreEqual(new AstLocation(7, 1), t.EndLocation);
 			t = l.NextToken();
 			Assert.AreEqual(Tokens.EOL, t.Kind);
-			Assert.AreEqual(new Location(7, 1), t.Location);
-			Assert.AreEqual(new Location(1, 2), t.EndLocation);
+			Assert.AreEqual(new AstLocation(7, 1), t.Location);
+			Assert.AreEqual(new AstLocation(1, 2), t.EndLocation);
 			t = l.NextToken();
 			Assert.AreEqual(Tokens.Static, t.Kind);
-			Assert.AreEqual(new Location(1, 2), t.Location);
-			Assert.AreEqual(new Location(7, 2), t.EndLocation);
+			Assert.AreEqual(new AstLocation(1, 2), t.Location);
+			Assert.AreEqual(new AstLocation(7, 2), t.EndLocation);
 		}
 		
 		[Test]
@@ -59,13 +59,13 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 			l.NextToken(); // public
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.EOL, t.Kind);
-			Assert.AreEqual(new Location(7, 1), t.Location);
-			Assert.AreEqual(new Location(7, 1), t.EndLocation);
+			Assert.AreEqual(new AstLocation(7, 1), t.Location);
+			Assert.AreEqual(new AstLocation(7, 1), t.EndLocation);
 			
 			t = l.NextToken();
 			Assert.AreEqual(Tokens.EOF, t.Kind);
-			Assert.AreEqual(new Location(7, 1), t.Location);
-			Assert.AreEqual(new Location(7, 1), t.EndLocation);
+			Assert.AreEqual(new AstLocation(7, 1), t.Location);
+			Assert.AreEqual(new AstLocation(7, 1), t.EndLocation);
 		}
 		
 		[Test]
@@ -75,13 +75,13 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 			l.NextToken(); // public
 			Token t = l.NextToken();
 			Assert.AreEqual(Tokens.EOL, t.Kind);
-			Assert.AreEqual(new Location(2, 2), t.Location);
-			Assert.AreEqual(new Location(2, 2), t.EndLocation);
+			Assert.AreEqual(new AstLocation(2, 2), t.Location);
+			Assert.AreEqual(new AstLocation(2, 2), t.EndLocation);
 			
 			t = l.NextToken();
 			Assert.AreEqual(Tokens.EOF, t.Kind);
-			Assert.AreEqual(new Location(2, 2), t.Location);
-			Assert.AreEqual(new Location(2, 2), t.EndLocation);
+			Assert.AreEqual(new AstLocation(2, 2), t.Location);
+			Assert.AreEqual(new AstLocation(2, 2), t.EndLocation);
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs
index b181f4851..9b2ec8386 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LexerTests.cs
@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	{
 		VBLexer GenerateLexer(StringReader sr)
 		{
-			return ParserFactory.CreateLexer(sr);
+			return new VBLexer(sr);
 		}
 
 		[Test]
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs
index c1f32fbaf..7572b916c 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/LiteralsTests.cs
@@ -13,7 +13,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Lexer
 	{
 		VBLexer GenerateLexer(StringReader sr)
 		{
-			return ParserFactory.CreateLexer(sr);
+			return new VBLexer(sr);
 		}
 		
 		Token GetSingleToken(string text)
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs
index e582bd2a1..e55c4f9b5 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Lexer/XmlModeLexerTests.cs
@@ -948,12 +948,12 @@ End Using";
 		#region Helpers
 		VBLexer GenerateLexer(StringReader sr)
 		{
-			return ParserFactory.CreateLexer(sr);
+			return new VBLexer(sr);
 		}
 		
 		VBLexer GenerateLexerForSnippet(StringReader sr, SnippetType type)
 		{
-			var lexer = ParserFactory.CreateLexer(sr);
+			var lexer = new VBLexer(sr);
 			lexer.SetInitialContext(type);
 			return lexer;
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/CodeDOM/InvocationExpressionTest.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/CodeDOM/InvocationExpressionTest.cs
index 94f52b45e..443dcfe3c 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/CodeDOM/InvocationExpressionTest.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/CodeDOM/InvocationExpressionTest.cs
@@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Output.CodeDom.Tests
 		public void IdentifierOnlyInvocation()
 		{
 			// InitializeComponents();
-			IdentifierExpression identifier = new IdentifierExpression("InitializeComponents");
+			SimpleNameExpression identifier = new SimpleNameExpression("InitializeComponents");
 			InvocationExpression invocation = new InvocationExpression(identifier, new List<Expression>());
 			object output = invocation.AcceptVisitor(new CodeDomVisitor(), null);
 			Assert.IsTrue(output is CodeMethodInvokeExpression);
@@ -44,7 +44,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Output.CodeDom.Tests
 		public void InvocationOfStaticMethod()
 		{
 			// System.Drawing.Color.FromArgb();
-			MemberReferenceExpression field = new MemberReferenceExpression(new IdentifierExpression("System"), "Drawing");
+			MemberReferenceExpression field = new MemberReferenceExpression(new SimpleNameExpression("System"), "Drawing");
 			field = new MemberReferenceExpression(field, "Color");
 			field = new MemberReferenceExpression(field, "FromArgb");
 			InvocationExpression invocation = new InvocationExpression(field, new List<Expression>());
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/SpecialOutputVisitorTest.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/SpecialOutputVisitorTest.cs
index 7e8961e63..5c0328ec2 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/SpecialOutputVisitorTest.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Output/SpecialOutputVisitorTest.cs
@@ -8,7 +8,7 @@ using System.IO;
 using ICSharpCode.NRefactory.VB.Ast;
 using ICSharpCode.NRefactory.VB.Parser;
 using ICSharpCode.NRefactory.VB.PrettyPrinter;
-using ICSharpCode.NRefactory.VB.Visitors;
+
 using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.VB.Tests.PrettyPrinter
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs
deleted file mode 100644
index 8c7a4f27e..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/CheckParentVisitor.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-using ICSharpCode.NRefactory.VB.Ast;
-using ICSharpCode.NRefactory.VB.Visitors;
-
-namespace ICSharpCode.NRefactory.VB.Tests.Ast
-{
-	/// <summary>
-	/// Ensures that all nodes have the Parent property correctly set.
-	/// </summary>
-	public class CheckParentVisitor : NodeTrackingAstVisitor
-	{
-		Stack<INode> nodeStack = new Stack<INode>();
-		
-		public CheckParentVisitor()
-		{
-			nodeStack.Push(null);
-		}
-		
-		protected override void BeginVisit(INode node)
-		{
-			nodeStack.Push(node);
-		}
-		
-		protected override void EndVisit(INode node)
-		{
-			Assert.AreSame(node, nodeStack.Pop(), "nodeStack was corrupted!");
-			Assert.AreSame(nodeStack.Peek(), node.Parent, "node " + node + " is missing parent: " + nodeStack.Peek());
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/BinaryOperatorExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/BinaryOperatorExpressionTests.cs
index 030d17132..256144aae 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/BinaryOperatorExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/BinaryOperatorExpressionTests.cs
@@ -20,20 +20,20 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			BinaryOperatorExpression boe;
 			boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program);
 			Assert.AreEqual(weakOperatorType, boe.Op);
-			Assert.IsTrue(boe.Left is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
 			boe = (BinaryOperatorExpression)boe.Right;
 			Assert.AreEqual(strongOperatorType, boe.Op);
-			Assert.IsTrue(boe.Left is IdentifierExpression);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 			
 			program = "a " + strongOperator + " b " + weakOperator + " c";
 			boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program);
 			Assert.AreEqual(weakOperatorType, boe.Op);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 			boe = (BinaryOperatorExpression)boe.Left;
 			Assert.AreEqual(strongOperatorType, boe.Op);
-			Assert.IsTrue(boe.Left is IdentifierExpression);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 		}
 		
 		void SameOperatorPrecedenceTest(string firstOperator, BinaryOperatorType firstOperatorType,
@@ -43,20 +43,20 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			BinaryOperatorExpression boe;
 			boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program);
 			Assert.AreEqual(firstOperatorType, boe.Op);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 			boe = (BinaryOperatorExpression)boe.Left;
 			Assert.AreEqual(secondOperatorType, boe.Op);
-			Assert.IsTrue(boe.Left is IdentifierExpression);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 			
 			program = "a " + firstOperator + " b " + secondOperator + " c";
 			boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program);
 			Assert.AreEqual(secondOperatorType, boe.Op);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 			boe = (BinaryOperatorExpression)boe.Left;
 			Assert.AreEqual(firstOperatorType, boe.Op);
-			Assert.IsTrue(boe.Left is IdentifierExpression);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 		}
 		
 		#region VB.NET
@@ -65,8 +65,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			BinaryOperatorExpression boe = ParseUtil.ParseExpression<BinaryOperatorExpression>(program);
 			Assert.AreEqual(op, boe.Op);
 			
-			Assert.IsTrue(boe.Left is IdentifierExpression);
-			Assert.IsTrue(boe.Right is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
+			Assert.IsTrue(boe.Right is SimpleNameExpression);
 		}
 		
 		[Test]
@@ -251,7 +251,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			BinaryOperatorExpression boe = ParseUtil.ParseExpression<BinaryOperatorExpression>("a!b");
 			Assert.AreEqual(BinaryOperatorType.DictionaryAccess, boe.Op);
-			Assert.IsTrue(boe.Left is IdentifierExpression);
+			Assert.IsTrue(boe.Left is SimpleNameExpression);
 			Assert.IsTrue(boe.Right is PrimitiveExpression);
 		}
 		
@@ -264,47 +264,5 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			Assert.IsTrue(boe.Right is PrimitiveExpression);
 		}
 		#endregion
-		
-		#region AddIntegerTests
-		string AddIntegerToBoe(string input, int number)
-		{
-			return AddInteger<BinaryOperatorExpression>(input, number);
-		}
-		
-		string AddInteger<T>(string input, int number) where T : Expression
-		{
-			Expression e = ParseUtil.ParseExpression<T>(input);
-			e = Expression.AddInteger(e, number);
-			VBNetOutputVisitor v = new VBNetOutputVisitor();
-			e.AcceptVisitor(v, null);
-			return v.Text;
-		}
-		
-		[Test]
-		public void AddInteger()
-		{
-			Assert.AreEqual("a + 2", AddIntegerToBoe("a + 1", 1));
-			Assert.AreEqual("a + 2", AddIntegerToBoe("a + 3", -1));
-			Assert.AreEqual("a + b + c + 2", AddIntegerToBoe("a + b + c + 1", 1));
-			Assert.AreEqual("a", AddIntegerToBoe("a + 1", -1));
-			Assert.AreEqual("2", AddInteger<PrimitiveExpression>("1", 1));
-			Assert.AreEqual("-1", AddInteger<PrimitiveExpression>("1", -2));
-			Assert.AreEqual("0", AddInteger<PrimitiveExpression>("1", -1));
-			Assert.AreEqual("a + 1", AddInteger<IdentifierExpression>("a", 1));
-		}
-		
-		[Test]
-		public void AddIntegerWithNegativeResult()
-		{
-			Assert.AreEqual("a - 1", AddIntegerToBoe("a + 1", -2));
-			Assert.AreEqual("a - 2", AddIntegerToBoe("a - 1", -1));
-			Assert.AreEqual("a + b + c - 2", AddIntegerToBoe("a + b + c + 2", -4));
-			Assert.AreEqual("a + b + c - 6", AddIntegerToBoe("a + b + c - 2", -4));
-			Assert.AreEqual("a + b + c", AddIntegerToBoe("a + b + c + 2", -2));
-			Assert.AreEqual("a", AddIntegerToBoe("a - 1", 1));
-			Assert.AreEqual("a + 1", AddIntegerToBoe("a - 2", 3));
-			Assert.AreEqual("a - 1", AddInteger<IdentifierExpression>("a", -1));
-		}
-		#endregion
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/CastExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/CastExpressionTests.cs
index b4ec88756..d93aa709d 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/CastExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/CastExpressionTests.cs
@@ -17,7 +17,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>(castExpression);
 			Assert.AreEqual(castType.FullName, ce.CastTo.Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.PrimitiveConversion, ce.CastType);
 		}
 		
@@ -27,7 +27,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>("CType(o, MyObject)");
 			Assert.AreEqual("MyObject", ce.CastTo.Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.Conversion, ce.CastType);
 		}
 		
@@ -37,7 +37,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>("CType(o, List(of T))");
 			Assert.AreEqual("List", ce.CastTo.Type);
 			Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.Conversion, ce.CastType);
 		}
 		
@@ -46,7 +46,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>("DirectCast(o, MyObject)");
 			Assert.AreEqual("MyObject", ce.CastTo.Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.Cast, ce.CastType);
 		}
 		
@@ -56,7 +56,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>("DirectCast(o, List(of T))");
 			Assert.AreEqual("List", ce.CastTo.Type);
 			Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.Cast, ce.CastType);
 		}
 		
@@ -65,7 +65,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>("TryCast(o, MyObject)");
 			Assert.AreEqual("MyObject", ce.CastTo.Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.TryCast, ce.CastType);
 		}
 		
@@ -75,7 +75,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			CastExpression ce = ParseUtil.ParseExpression<CastExpression>("TryCast(o, List(of T))");
 			Assert.AreEqual("List", ce.CastTo.Type);
 			Assert.AreEqual("T", ce.CastTo.GenericTypes[0].Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 			Assert.AreEqual(CastType.TryCast, ce.CastType);
 		}
 		
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/InvocationExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/InvocationExpressionTests.cs
index 8fbe1c289..dcc4e731c 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/InvocationExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/InvocationExpressionTests.cs
@@ -15,15 +15,15 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		void CheckSimpleInvoke(InvocationExpression ie)
 		{
 			Assert.AreEqual(0, ie.Arguments.Count);
-			Assert.IsTrue(ie.TargetObject is IdentifierExpression);
-			Assert.AreEqual("myMethod", ((IdentifierExpression)ie.TargetObject).Identifier);
+			Assert.IsTrue(ie.TargetObject is SimpleNameExpression);
+			Assert.AreEqual("myMethod", ((SimpleNameExpression)ie.TargetObject).Identifier);
 		}
 		
 		void CheckGenericInvoke(InvocationExpression expr)
 		{
 			Assert.AreEqual(1, expr.Arguments.Count);
-			Assert.IsTrue(expr.TargetObject is IdentifierExpression);
-			IdentifierExpression ident = (IdentifierExpression)expr.TargetObject;
+			Assert.IsTrue(expr.TargetObject is SimpleNameExpression);
+			SimpleNameExpression ident = (SimpleNameExpression)expr.TargetObject;
 			Assert.AreEqual("myMethod", ident.Identifier);
 			Assert.AreEqual(1, ident.TypeArguments.Count);
 			Assert.AreEqual("System.Char", ident.TypeArguments[0].Type);
@@ -32,8 +32,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		void CheckGenericInvoke2(InvocationExpression expr)
 		{
 			Assert.AreEqual(0, expr.Arguments.Count);
-			Assert.IsTrue(expr.TargetObject is IdentifierExpression);
-			IdentifierExpression ident = (IdentifierExpression)expr.TargetObject;
+			Assert.IsTrue(expr.TargetObject is SimpleNameExpression);
+			SimpleNameExpression ident = (SimpleNameExpression)expr.TargetObject;
 			Assert.AreEqual("myMethod", ident.Identifier);
 			Assert.AreEqual(2, ident.TypeArguments.Count);
 			Assert.AreEqual("T", ident.TypeArguments[0].Type);
@@ -74,7 +74,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("A(Of T).Foo()");
 			MemberReferenceExpression mre = (MemberReferenceExpression)expr.TargetObject;
 			Assert.AreEqual("Foo", mre.MemberName);
-			IdentifierExpression tre = (IdentifierExpression)mre.TargetObject;
+			SimpleNameExpression tre = (SimpleNameExpression)mre.TargetObject;
 			Assert.AreEqual("A", tre.Identifier);
 			Assert.AreEqual("T", tre.TypeArguments[0].Type);
 		}
@@ -87,7 +87,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			Assert.AreEqual("Foo", mre.MemberName);
 			MemberReferenceExpression mre2 = (MemberReferenceExpression)mre.TargetObject;
 			Assert.AreEqual("B", mre2.MemberName);
-			IdentifierExpression tre = (IdentifierExpression)mre2.TargetObject;
+			SimpleNameExpression tre = (SimpleNameExpression)mre2.TargetObject;
 			Assert.AreEqual("A", tre.Identifier);
 			Assert.AreEqual("T", tre.TypeArguments[0].Type);
 		}
@@ -106,7 +106,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			MemberReferenceExpression mre3 = (MemberReferenceExpression)mre2.TargetObject;
 			Assert.AreEqual("B", mre3.MemberName);
 			
-			IdentifierExpression tre = (IdentifierExpression)mre3.TargetObject;
+			SimpleNameExpression tre = (SimpleNameExpression)mre3.TargetObject;
 			Assert.AreEqual("A", tre.Identifier);
 			Assert.AreEqual("T", tre.TypeArguments[0].Type);
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/MemberReferenceExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/MemberReferenceExpressionTests.cs
index bdf73af4b..94efda65b 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/MemberReferenceExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/MemberReferenceExpressionTests.cs
@@ -18,8 +18,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("myTargetObject.myField");
 			Assert.AreEqual("myField", fre.MemberName);
-			Assert.IsTrue(fre.TargetObject is IdentifierExpression);
-			Assert.AreEqual("myTargetObject", ((IdentifierExpression)fre.TargetObject).Identifier);
+			Assert.IsTrue(fre.TargetObject is SimpleNameExpression);
+			Assert.AreEqual("myTargetObject", ((SimpleNameExpression)fre.TargetObject).Identifier);
 		}
 		
 		[Test]
@@ -35,8 +35,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			MemberReferenceExpression fre = ParseUtil.ParseExpression<MemberReferenceExpression>("SomeClass(of string).myField");
 			Assert.AreEqual("myField", fre.MemberName);
-			Assert.IsInstanceOf(typeof(IdentifierExpression), fre.TargetObject);
-			TypeReference tr = ((IdentifierExpression)fre.TargetObject).TypeArguments[0];
+			Assert.IsInstanceOf(typeof(SimpleNameExpression), fre.TargetObject);
+			TypeReference tr = ((SimpleNameExpression)fre.TargetObject).TypeArguments[0];
 			Assert.AreEqual("System.String", tr.Type);
 		}
 		
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs
index 478dcf330..2b6a8f886 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/ObjectCreateExpressionTests.cs
@@ -53,8 +53,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			Assert.AreEqual(0, oce.Parameters.Count);
 			Assert.AreEqual(1, oce.ObjectInitializer.CreateExpressions.Count);
 			
-			Assert.IsInstanceOf(typeof(IdentifierExpression), oce.ObjectInitializer.CreateExpressions[0]);
-			Assert.AreEqual("c", (oce.ObjectInitializer.CreateExpressions[0] as IdentifierExpression).Identifier);
+			Assert.IsInstanceOf(typeof(SimpleNameExpression), oce.ObjectInitializer.CreateExpressions[0]);
+			Assert.AreEqual("c", (oce.ObjectInitializer.CreateExpressions[0] as SimpleNameExpression).Identifier);
 		}
 		
 		[Test]
@@ -69,8 +69,8 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			// this test was written because this bug caused the AbstractDomVisitor to crash
 			
 			InvocationExpression expr = ParseUtil.ParseExpression<InvocationExpression>("WriteLine(New SomeGenericType(Of Integer, )())", true);
-			Assert.IsTrue(expr.TargetObject is IdentifierExpression);
-			Assert.AreEqual("WriteLine", ((IdentifierExpression)expr.TargetObject).Identifier);
+			Assert.IsTrue(expr.TargetObject is SimpleNameExpression);
+			Assert.AreEqual("WriteLine", ((SimpleNameExpression)expr.TargetObject).Identifier);
 			Assert.AreEqual(1, expr.Arguments.Count); // here a second null parameter was added incorrectly
 			
 			Assert.IsTrue(expr.Arguments[0] is ObjectCreateExpression);
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/QueryExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/QueryExpressionTests.cs
index dad3349c4..8d46f278e 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/QueryExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/QueryExpressionTests.cs
@@ -225,7 +225,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			Action<QueryExpression> constraint = expr => {
 				var fromClause = expr.Clauses[0] as QueryExpressionFromClause;
 				var groupClause = expr.Clauses[1] as QueryExpressionGroupVBClause;
-				var letClause = expr.Clauses[2] as QueryExpressionLetVBClause;
+				var letClause = expr.Clauses[2] as QueryExpressionLetClause;
 				var selectClause = expr.Clauses[3] as QueryExpressionSelectVBClause;
 				
 				// From
@@ -276,7 +276,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
             Group p By p.Category Into Group _
             Let minPrice = Group.Min(Function(p) p.UnitPrice) _
             Select Category, CheapestProducts = Group.Where(Function(p) p.UnitPrice = minPrice)", 4, constraint,
-			        typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionLetVBClause), typeof(QueryExpressionSelectVBClause));
+			        typeof(QueryExpressionFromClause), typeof(QueryExpressionGroupVBClause), typeof(QueryExpressionLetClause), typeof(QueryExpressionSelectVBClause));
 		}
 		
 		[Test]
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/TypeOfIsExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/TypeOfIsExpressionTests.cs
index 9d7da043d..46f7e959e 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/TypeOfIsExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/TypeOfIsExpressionTests.cs
@@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		{
 			TypeOfIsExpression ce = ParseUtil.ParseExpression<TypeOfIsExpression>("TypeOf o Is MyObject");
 			Assert.AreEqual("MyObject", ce.TypeReference.Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 		}
 		
 		[Test]
@@ -27,7 +27,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			TypeOfIsExpression ce = ParseUtil.ParseExpression<TypeOfIsExpression>("TypeOf o Is List(of T)");
 			Assert.AreEqual("List", ce.TypeReference.Type);
 			Assert.AreEqual("T", ce.TypeReference.GenericTypes[0].Type);
-			Assert.IsTrue(ce.Expression is IdentifierExpression);
+			Assert.IsTrue(ce.Expression is SimpleNameExpression);
 		}
 		#endregion
 	}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/UnaryOperatorExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/UnaryOperatorExpressionTests.cs
index 5bbaa66f1..b5100b2cd 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/UnaryOperatorExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/UnaryOperatorExpressionTests.cs
@@ -18,7 +18,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			UnaryOperatorExpression uoe = ParseUtil.ParseExpression<UnaryOperatorExpression>(program);
 			Assert.AreEqual(op, uoe.Op);
 			
-			Assert.IsTrue(uoe.Expression is IdentifierExpression);
+			Assert.IsTrue(uoe.Expression is SimpleNameExpression);
 		}
 		
 		[Test]
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/XmlExpressionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/XmlExpressionTests.cs
index cc9012cc6..e36b43b0d 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/XmlExpressionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Expressions/XmlExpressionTests.cs
@@ -230,7 +230,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		}
 		#endregion
 		
-		void CheckElement(INode node, string name, Location start, Location end)
+		void CheckElement(AstNode node, string name, AstLocation start, AstLocation end)
 		{
 			Assert.IsTrue(node is XmlElementExpression);
 			XmlElementExpression expr = node as XmlElementExpression;
@@ -242,7 +242,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 			Assert.AreEqual(end, expr.EndLocation);
 		}
 		
-		void CheckContent(INode node, string content, XmlContentType type, Location start, Location end)
+		void CheckContent(AstNode node, string content, XmlContentType type, AstLocation start, AstLocation end)
 		{
 			Assert.IsTrue(node is XmlContentExpression);
 			XmlContentExpression expr = node as XmlContentExpression;
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/AttributeSectionTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/AttributeSectionTests.cs
index 8a877ed9e..997e2dc11 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/AttributeSectionTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/AttributeSectionTests.cs
@@ -12,63 +12,63 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 	[TestFixture]
 	public class AttributeSectionTests
 	{
-		[Test]
-		public void AttributeOnStructure()
-		{
-			string program = @"
-<StructLayout( LayoutKind.Explicit )> _
-Public Structure MyUnion
-
-	<FieldOffset( 0 )> Public i As Integer
-	< FieldOffset( 0 )> Public d As Double
-	
-End Structure 'MyUnion
-";
-			TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			Assert.AreEqual("StructLayout", decl.Attributes[0].Attributes[0].Name);
-		}
-		
-		[Test]
-		public void AttributeOnModule()
-		{
-			string program = @"
-<HideModule> _
-Public Module MyExtra
-
-	Public i As Integer
-	Public d As Double
-	
-End Module
-";
-			TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			Assert.AreEqual("HideModule", decl.Attributes[0].Attributes[0].Name);
-		}
-		
-		[Test]
-		public void GlobalAttribute()
-		{
-			string program = @"<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
-Public Class Form1
-	
-End Class";
-			TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			Assert.AreEqual("Microsoft.VisualBasic.CompilerServices.DesignerGenerated", decl.Attributes[0].Attributes[0].Name);
-		}
-		
-		[Test]
-		public void AssemblyAttribute()
-		{
-			string program = @"<assembly: System.Attribute()>";
-			AttributeSection decl = ParseUtil.ParseGlobal<AttributeSection>(program);
-			Assert.AreEqual(new Location(1, 1), decl.StartLocation);
-			Assert.AreEqual("assembly", decl.AttributeTarget);
-		}
-		
-		[Test]
-		public void ModuleAttributeTargetEscaped()
-		{
-			// check that this doesn't crash the parser:
-			ParseUtil.ParseGlobal<AttributeSection>("<[Module]: SuppressMessageAttribute>", true);
-		}
+//		[Test]
+//		public void AttributeOnStructure()
+//		{
+//			string program = @"
+//<StructLayout( LayoutKind.Explicit )> _
+//Public Structure MyUnion
+//
+//	<FieldOffset( 0 )> Public i As Integer
+//	< FieldOffset( 0 )> Public d As Double
+//	
+//End Structure 'MyUnion
+//";
+//			TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			Assert.AreEqual("StructLayout", decl.Attributes[0].Attributes[0].Type);
+//		}
+//		
+//		[Test]
+//		public void AttributeOnModule()
+//		{
+//			string program = @"
+//<HideModule> _
+//Public Module MyExtra
+//
+//	Public i As Integer
+//	Public d As Double
+//	
+//End Module
+//";
+//			TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			Assert.AreEqual("HideModule", decl.Attributes[0].Attributes[0].Type);
+//		}
+//		
+//		[Test]
+//		public void GlobalAttribute()
+//		{
+//			string program = @"<Global.Microsoft.VisualBasic.CompilerServices.DesignerGenerated()> _
+//Public Class Form1
+//	
+//End Class";
+//			TypeDeclaration decl = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			Assert.AreEqual("Microsoft.VisualBasic.CompilerServices.DesignerGenerated", decl.Attributes[0].Attributes[0].Type);
+//		}
+//		
+//		[Test]
+//		public void AssemblyAttribute()
+//		{
+//			string program = @"<assembly: System.Attribute()>";
+//			AttributeSection decl = ParseUtil.ParseGlobal<AttributeSection>(program);
+//			Assert.AreEqual(new Location(1, 1), decl.StartLocation);
+//			Assert.AreEqual("assembly", decl.AttributeTarget);
+//		}
+//		
+//		[Test]
+//		public void ModuleAttributeTargetEscaped()
+//		{
+//			// check that this doesn't crash the parser:
+//			ParseUtil.ParseGlobal<AttributeSection>("<[Module]: SuppressMessageAttribute>", true);
+//		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/DelegateDeclarationTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/DelegateDeclarationTests.cs
deleted file mode 100644
index 3328c8f2c..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/DelegateDeclarationTests.cs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.NRefactory.VB.Ast;
-using NUnit.Framework;
-
-namespace ICSharpCode.NRefactory.VB.Tests.Ast
-{
-	[TestFixture]
-	public class DelegateDeclarationTests
-	{
-		void TestDelegateDeclaration(DelegateDeclaration dd)
-		{
-			Assert.AreEqual("System.Void", dd.ReturnType.Type);
-			Assert.AreEqual("MyDelegate", dd.Name);
-		}
-		
-		void TestParameters(DelegateDeclaration dd)
-		{
-			Assert.AreEqual(3, dd.Parameters.Count);
-			
-			Assert.AreEqual("a", ((ParameterDeclarationExpression)dd.Parameters[0]).ParameterName);
-			Assert.AreEqual("System.Int32", ((ParameterDeclarationExpression)dd.Parameters[0]).TypeReference.Type);
-			
-			Assert.AreEqual("secondParam", ((ParameterDeclarationExpression)dd.Parameters[1]).ParameterName);
-			Assert.AreEqual("System.Int32", ((ParameterDeclarationExpression)dd.Parameters[1]).TypeReference.Type);
-			
-			Assert.AreEqual("lastParam", ((ParameterDeclarationExpression)dd.Parameters[2]).ParameterName);
-			Assert.AreEqual("MyObj", ((ParameterDeclarationExpression)dd.Parameters[2]).TypeReference.Type);
-		}
-		
-		#region VB.NET
-		[Test]
-		public void SimpleVBNetDelegateDeclarationTest()
-		{
-			string program = "Public Delegate Sub MyDelegate(ByVal a As Integer, ByVal secondParam As Integer, ByVal lastParam As MyObj)\n";
-			TestDelegateDeclaration(ParseUtil.ParseGlobal<DelegateDeclaration>(program));
-		}
-		#endregion
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/ImportsStatementTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/ImportsStatementTests.cs
new file mode 100644
index 000000000..0e7546f9e
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/ImportsStatementTests.cs
@@ -0,0 +1,168 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.IO;
+using ICSharpCode.NRefactory.VB.Parser;
+using ICSharpCode.NRefactory.VB.Ast;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.VB.Tests.Ast
+{
+	[TestFixture]
+	public class ImportsStatementTests
+	{
+		[Test]
+		public void InvalidImportsStatement()
+		{
+			string program = "Imports\n";
+			ParseUtil.ParseGlobal<ImportsStatement>(program, true);
+		}
+		
+		[Test]
+		public void InvalidImportsStatement2()
+		{
+			string program = "Imports ,\n";
+			ParseUtil.ParseGlobal<ImportsStatement>(program, true);
+		}
+		
+		[Test]
+		public void SimpleImportsStatement()
+		{
+			string program = "Imports System\n";
+			
+			var clause1 = new MemberImportsClause {
+				Member = new SimpleType("System")
+			};
+			
+			var node = new ImportsStatement();
+			node.AddChild(clause1, ImportsStatement.ImportsClauseRole);
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+		
+		[Test]
+		public void QualifiedTypeImportsStatement()
+		{
+			string program = "Imports My.Name.Space\n";
+			
+			var clause2 = new MemberImportsClause {
+				Member = new QualifiedType(new QualifiedType(new SimpleType("My"), new Identifier("Name", AstLocation.Empty)), new Identifier("Space", AstLocation.Empty))
+			};
+			
+			var node = new ImportsStatement();
+			node.AddChild(clause2, ImportsStatement.ImportsClauseRole);
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+//
+//		[Test]
+//		public void VBNetUsingAliasDeclarationTest()
+//		{
+//			string program = "Imports TESTME=System\n" +
+//				"Imports myAlias=My.Name.Space\n" +
+//				"Imports StringCollection = System.Collections.Generic.List(Of string)\n";
+//			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
+//			parser.Parse();
+//
+//			Assert.AreEqual("", parser.Errors.ErrorOutput);
+//			CheckAliases(parser.CompilationUnit);
+//		}
+//
+//		[Test]
+//		public void VBNetComplexUsingAliasDeclarationTest()
+//		{
+//			string program = "Imports NS1, AL=NS2, NS3, AL2=NS4, NS5\n";
+//			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
+//			parser.Parse();
+//
+//			Assert.AreEqual("", parser.Errors.ErrorOutput);
+//			// TODO : Extend test ...
+//		}
+//
+//		[Test]
+//		public void VBNetXmlNamespaceUsingTest()
+//		{
+//			string program = "Imports <xmlns=\"http://icsharpcode.net/sharpdevelop/avalonedit\">";
+//			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
+//			parser.Parse();
+//
+//			Assert.AreEqual("", parser.Errors.ErrorOutput);
+//			CompilationUnit unit = parser.CompilationUnit;
+//
+//			Assert.AreEqual(1, unit.Children.Count);
+//			Assert.IsTrue(unit.Children[0] is ImportsStatement);
+//			ImportsStatement ud = (ImportsStatement)unit.Children[0];
+//			Assert.AreEqual(1, ud.ImportsClauses.Count);
+//			Assert.IsFalse(ud.ImportsClauses[0].IsAlias);
+//			Assert.IsTrue(ud.ImportsClauses[0].IsXml);
+//
+//			Assert.AreEqual("xmlns", ud.ImportsClauses[0].XmlPrefix);
+//			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.ImportsClauses[0].Name);
+//		}
+//
+//		[Test]
+//		public void VBNetXmlNamespaceWithPrefixUsingTest()
+//		{
+//			string program = "Imports <xmlns:avalonedit=\"http://icsharpcode.net/sharpdevelop/avalonedit\">";
+//			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
+//			parser.Parse();
+//
+//			Assert.AreEqual("", parser.Errors.ErrorOutput);
+//			CompilationUnit unit = parser.CompilationUnit;
+//
+//			Assert.AreEqual(1, unit.Children.Count);
+//			Assert.IsTrue(unit.Children[0] is ImportsStatement);
+//			ImportsStatement ud = (ImportsStatement)unit.Children[0];
+//			Assert.AreEqual(1, ud.ImportsClauses.Count);
+//			Assert.IsFalse(ud.ImportsClauses[0].IsAlias);
+//			Assert.IsTrue(ud.ImportsClauses[0].IsXml);
+//
+//			Assert.AreEqual("xmlns:avalonedit", ud.ImportsClauses[0].XmlPrefix);
+//			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.ImportsClauses[0].Name);
+//		}
+//
+//		[Test]
+//		public void VBNetXmlNamespaceSingleQuotedUsingTest()
+//		{
+//			string program = "Imports <xmlns='http://icsharpcode.net/sharpdevelop/avalonedit'>";
+//			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
+//			parser.Parse();
+//
+//			Assert.AreEqual("", parser.Errors.ErrorOutput);
+//			CompilationUnit unit = parser.CompilationUnit;
+//
+//			Assert.AreEqual(1, unit.Children.Count);
+//			Assert.IsTrue(unit.Children[0] is ImportsStatement);
+//			ImportsStatement ud = (ImportsStatement)unit.Children[0];
+//			Assert.AreEqual(1, ud.ImportsClauses.Count);
+//			Assert.IsFalse(ud.ImportsClauses[0].IsAlias);
+//			Assert.IsTrue(ud.ImportsClauses[0].IsXml);
+//
+//			Assert.AreEqual("xmlns", ud.ImportsClauses[0].XmlPrefix);
+//			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.ImportsClauses[0].Name);
+//		}
+//
+//		[Test]
+//		public void VBNetXmlNamespaceSingleQuotedWithPrefixUsingTest()
+//		{
+//			string program = "Imports <xmlns:avalonedit='http://icsharpcode.net/sharpdevelop/avalonedit'>";
+//			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
+//			parser.Parse();
+//
+//			Assert.AreEqual("", parser.Errors.ErrorOutput);
+//			CompilationUnit unit = parser.CompilationUnit;
+//
+//			Assert.AreEqual(1, unit.Children.Count);
+//			Assert.IsTrue(unit.Children[0] is ImportsStatement);
+//			ImportsStatement ud = (ImportsStatement)unit.Children[0];
+//			Assert.AreEqual(1, ud.ImportsClauses.Count);
+//			Assert.IsFalse(ud.ImportsClauses[0].IsAlias);
+//			Assert.IsTrue(ud.ImportsClauses[0].IsXml);
+//
+//			Assert.AreEqual("xmlns:avalonedit", ud.ImportsClauses[0].XmlPrefix);
+//			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.ImportsClauses[0].Name);
+//		}
+//		#endregion
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/NamespaceDeclarationTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/NamespaceDeclarationTests.cs
index ca6dd92d7..33f994443 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/NamespaceDeclarationTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/NamespaceDeclarationTests.cs
@@ -10,34 +10,34 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 	[TestFixture]
 	public class NamespaceDeclarationTests
 	{
-		#region VB.NET
-		[Test]
-		public void VBNetSimpleNamespaceTest()
-		{
-			string program = "Namespace TestNamespace" + Environment.NewLine +
-			                 "End Namespace" +Environment.NewLine;
-			NamespaceDeclaration ns = ParseUtil.ParseGlobal<NamespaceDeclaration>(program);
-			Assert.AreEqual("TestNamespace", ns.Name);
-		}
-		
-		[Test]
-		public void VBNetJuggedNamespaceTest()
-		{
-			string program = "Namespace N1 'TestNamespace\n" +
-			                 "    Namespace N2   ' Declares a namespace named N2 within N1.\n" +
-			                 "    End Namespace\n" +
-			                 "End Namespace\n";
-			
-			NamespaceDeclaration ns = ParseUtil.ParseGlobal<NamespaceDeclaration>(program);
-			
-			Assert.AreEqual("N1", ns.Name);
-			
-			Assert.IsTrue(ns.Children[0] is NamespaceDeclaration);
-			
-			ns = (NamespaceDeclaration)ns.Children[0];
-			
-			Assert.AreEqual("N2", ns.Name);
-		}
-		#endregion
+//		#region VB.NET
+//		[Test]
+//		public void VBNetSimpleNamespaceTest()
+//		{
+//			string program = "Namespace TestNamespace" + Environment.NewLine +
+//			                 "End Namespace" +Environment.NewLine;
+//			NamespaceDeclaration ns = ParseUtil.ParseGlobal<NamespaceDeclaration>(program);
+//			Assert.AreEqual("TestNamespace", ns.Name);
+//		}
+//		
+//		[Test]
+//		public void VBNetJuggedNamespaceTest()
+//		{
+//			string program = "Namespace N1 'TestNamespace\n" +
+//			                 "    Namespace N2   ' Declares a namespace named N2 within N1.\n" +
+//			                 "    End Namespace\n" +
+//			                 "End Namespace\n";
+//			
+//			NamespaceDeclaration ns = ParseUtil.ParseGlobal<NamespaceDeclaration>(program);
+//			
+//			Assert.AreEqual("N1", ns.Name);
+//			
+//			Assert.IsTrue(ns.Children[0] is NamespaceDeclaration);
+//			
+//			ns = (NamespaceDeclaration)ns.Children[0];
+//			
+//			Assert.AreEqual("N2", ns.Name);
+//		}
+//		#endregion
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/OptionDeclarationTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/OptionDeclarationTests.cs
deleted file mode 100644
index cf1b9ba98..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/OptionDeclarationTests.cs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.IO;
-using ICSharpCode.NRefactory.VB.Parser;
-using ICSharpCode.NRefactory.VB.Ast;
-using NUnit.Framework;
-
-namespace ICSharpCode.NRefactory.VB.Tests.Ast
-{
-	[TestFixture]
-	public class OptionDeclarationTests
-	{
-		[Test]
-		public void VBNetStrictOptionDeclarationTest()
-		{
-			string program = "Option Strict On\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.Strict, opDec.OptionType);
-			Assert.IsTrue(opDec.OptionValue);
-		}
-		
-		[Test]
-		public void VBNetExplicitOptionDeclarationTest()
-		{
-			string program = "Option Explicit Off\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.Explicit, opDec.OptionType);
-			Assert.IsFalse(opDec.OptionValue, "Off option value excepted!");
-		}
-		
-		[Test]
-		public void VBNetCompareBinaryOptionDeclarationTest()
-		{
-			string program = "Option Compare Binary\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.CompareBinary, opDec.OptionType);
-			Assert.IsTrue(opDec.OptionValue);
-		}
-		
-		[Test]
-		public void VBNetCompareTextOptionDeclarationTest()
-		{
-			string program = "Option Compare Text\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.CompareText, opDec.OptionType);
-			Assert.IsTrue(opDec.OptionValue);
-		}
-
-		[Test]
-		public void VBNetInferOnOptionDeclarationTest()
-		{
-			string program = "Option Infer On\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.Infer, opDec.OptionType);
-			Assert.IsTrue(opDec.OptionValue);
-		}
-
-		[Test]
-		public void VBNetInferOffOptionDeclarationTest()
-		{
-			string program = "Option Infer\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.Infer, opDec.OptionType);
-			Assert.IsTrue(opDec.OptionValue);
-		}
-		
-		[Test]
-		public void VBNetInferOptionDeclarationTest()
-		{
-			string program = "Option Infer\n";
-			OptionDeclaration opDec = ParseUtil.ParseGlobal<OptionDeclaration>(program);
-			Assert.AreEqual(OptionType.Infer, opDec.OptionType);
-			Assert.IsTrue(opDec.OptionValue);
-		}
-		
-		[Test]
-		public void VBNetInvalidOptionDeclarationTest()
-		{
-			string program = "Option\n";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			Assert.IsFalse(parser.Errors.ErrorOutput.Length == 0, "Expected errors, but operation completed successfully");
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/OptionStatementTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/OptionStatementTests.cs
new file mode 100644
index 000000000..a3b28897a
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/OptionStatementTests.cs
@@ -0,0 +1,113 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.IO;
+using ICSharpCode.NRefactory.VB.Parser;
+using ICSharpCode.NRefactory.VB.Ast;
+using NUnit.Framework;
+
+namespace ICSharpCode.NRefactory.VB.Tests.Ast
+{
+	[TestFixture]
+	public class OptionStatementTests
+	{
+		[Test]
+		public void InvalidOptionSyntax()
+		{
+			string program = "Option\n";
+			ParseUtil.ParseGlobal<OptionStatement>(program, true);
+		}
+		
+		[Test]
+		public void StrictOption()
+		{
+			string program = "Option Strict On\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Strict,
+				OptionValue = OptionValue.On
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+		
+		[Test]
+		public void ExplicitOption()
+		{
+			string program = "Option Explicit Off\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Explicit,
+				OptionValue = OptionValue.Off
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+		
+		[Test]
+		public void CompareBinaryOption()
+		{
+			string program = "Option Compare Binary\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Compare,
+				OptionValue = OptionValue.Binary
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+
+		[Test]
+		public void CompareTextOption()
+		{
+			string program = "Option Compare Text\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Compare,
+				OptionValue = OptionValue.Text
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+
+		[Test]
+		public void InferOnOption()
+		{
+			string program = "Option Infer On\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Infer,
+				OptionValue = OptionValue.On
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+
+		[Test]
+		public void InferOffOption()
+		{
+			string program = "Option Infer Off\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Infer,
+				OptionValue = OptionValue.Off
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+
+		[Test]
+		public void InferOption()
+		{
+			string program = "Option Infer\n";
+			
+			var node = new OptionStatement {
+				OptionType = OptionType.Infer,
+				OptionValue = OptionValue.On
+			};
+			
+			ParseUtil.AssertGlobal(program, node);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/TypeDeclarationTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/TypeDeclarationTests.cs
index 39e41144a..cc71f4c09 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/TypeDeclarationTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/TypeDeclarationTests.cs
@@ -10,194 +10,194 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 	[TestFixture]
 	public class TypeDeclarationTests
 	{
-		#region VB.NET
-		[Test]
-		public void VBNetSimpleClassTypeDeclarationTest()
-		{
-			string program = "Class TestClass\n" +
-				"End Class\n";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestClass", td.Name);
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual(1, td.StartLocation.Line, "start line");
-			Assert.AreEqual(1, td.BodyStartLocation.Line, "bodystart line");
-			Assert.AreEqual(16, td.BodyStartLocation.Column, "bodystart col");
-			Assert.AreEqual(2, td.EndLocation.Line, "end line");
-			Assert.AreEqual(10, td.EndLocation.Column, "end col");
-		}
-		
-		[Test]
-		public void VBNetMissingBaseClassTest()
-		{
-			// SD2-1499: test that this invalid code doesn't crash
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>("public class test inherits", true);
-			Assert.AreEqual(0, td.BaseTypes.Count);
-		}
-		
-		[Test]
-		public void VBNetEnumWithBaseClassDeclarationTest()
-		{
-			string program = "Enum TestEnum As Byte\n" +
-				"End Enum\n";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestEnum", td.Name);
-			Assert.AreEqual(ClassType.Enum, td.Type);
-			Assert.AreEqual("System.Byte", td.BaseTypes[0].Type);
-			Assert.AreEqual(0, td.Children.Count);
-		}
-		
-		[Test]
-		public void VBNetEnumOnSingleLine()
-		{
-			string program = "Enum TestEnum : A : B = 1 : C : End Enum";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestEnum", td.Name);
-			Assert.AreEqual(ClassType.Enum, td.Type);
-			Assert.AreEqual(3, td.Children.Count);
-		}
-		
-		[Test]
-		public void VBNetEnumOnSingleLine2()
-		{
-			string program = "Enum TestEnum : A : : B = 1 :: C : End Enum";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestEnum", td.Name);
-			Assert.AreEqual(ClassType.Enum, td.Type);
-			Assert.AreEqual(3, td.Children.Count);
-		}
-		
-		
-		[Test]
-		public void VBNetEnumWithSystemBaseClassDeclarationTest()
-		{
-			string program = "Enum TestEnum As System.UInt16\n" +
-				"End Enum\n";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestEnum", td.Name);
-			Assert.AreEqual(ClassType.Enum, td.Type);
-			Assert.AreEqual("System.UInt16", td.BaseTypes[0].Type);
-			Assert.AreEqual(0, td.Children.Count);
-		}
-		
-		[Test]
-		public void VBNetSimpleClassTypeDeclarationWithoutLastNewLineTest()
-		{
-			string program = "Class TestClass\n" +
-				"End Class";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestClass", td.Name);
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual(1, td.StartLocation.Line, "start line");
-			Assert.AreEqual(2, td.EndLocation.Line, "end line");
-		}
-		
-		[Test]
-		public void VBNetSimpleClassTypeDeclarationWithColon()
-		{
-			string program = "Class TestClass\n" +
-				" : \n" +
-				"End Class";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestClass", td.Name);
-			Assert.AreEqual(ClassType.Class, td.Type);
-		}
-		
-		[Test]
-		public void VBNetSimplePartialClassTypeDeclarationTest()
-		{
-			string program = "Partial Class TestClass\n" +
-				"End Class\n";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestClass", td.Name);
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual(Modifiers.Partial, td.Modifier);
-		}
-		
-		[Test]
-		public void VBNetPartialPublicClass()
-		{
-			string program = "Partial Public Class TestClass\nEnd Class\n";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
-			
-			Assert.AreEqual("TestClass", td.Name);
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual(Modifiers.Partial | Modifiers.Public, td.Modifier);
-		}
-		
-		[Test]
-		public void VBNetGenericClassTypeDeclarationTest()
-		{
-			string declr = @"
-Public Class Test(Of T)
-
-End Class
-";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
-			
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual("Test", td.Name);
-			Assert.AreEqual(Modifiers.Public, td.Modifier);
-			Assert.AreEqual(0, td.BaseTypes.Count);
-			Assert.AreEqual(1, td.Templates.Count);
-			Assert.AreEqual("T", td.Templates[0].Name);
-		}
-		
-		[Test]
-		public void VBNetGenericClassWithConstraint()
-		{
-			string declr = @"
-Public Class Test(Of T As IMyInterface)
-
-End Class
-";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
-			
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual("Test", td.Name);
-			
-			Assert.AreEqual(1, td.Templates.Count);
-			Assert.AreEqual("T", td.Templates[0].Name);
-			Assert.AreEqual("IMyInterface", td.Templates[0].Bases[0].Type);
-		}
-		
-		[Test]
-		public void VBNetComplexGenericClassTypeDeclarationTest()
-		{
-			string declr = @"
-Public Class Generic(Of T As MyNamespace.IMyInterface, S As {G(Of T()), IAnotherInterface})
-	Implements System.IComparable
-
-End Class
-";
-			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
-			
-			Assert.AreEqual(ClassType.Class, td.Type);
-			Assert.AreEqual("Generic", td.Name);
-			Assert.AreEqual(Modifiers.Public, td.Modifier);
-			Assert.AreEqual(1, td.BaseTypes.Count);
-			Assert.AreEqual("System.IComparable", td.BaseTypes[0].Type);
-			
-			Assert.AreEqual(2, td.Templates.Count);
-			Assert.AreEqual("T", td.Templates[0].Name);
-			Assert.AreEqual("MyNamespace.IMyInterface", td.Templates[0].Bases[0].Type);
-			
-			Assert.AreEqual("S", td.Templates[1].Name);
-			Assert.AreEqual(2, td.Templates[1].Bases.Count);
-			Assert.AreEqual("G", td.Templates[1].Bases[0].Type);
-			Assert.AreEqual(1, td.Templates[1].Bases[0].GenericTypes.Count);
-			Assert.IsTrue(td.Templates[1].Bases[0].GenericTypes[0].IsArrayType);
-			Assert.AreEqual("T", td.Templates[1].Bases[0].GenericTypes[0].Type);
-			Assert.AreEqual(new int[] {0}, td.Templates[1].Bases[0].GenericTypes[0].RankSpecifier);
-			Assert.AreEqual("IAnotherInterface", td.Templates[1].Bases[1].Type);
-		}
-		#endregion
+//		#region VB.NET
+//		[Test]
+//		public void VBNetSimpleClassTypeDeclarationTest()
+//		{
+//			string program = "Class TestClass\n" +
+//				"End Class\n";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestClass", td.Name);
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual(1, td.StartLocation.Line, "start line");
+//			Assert.AreEqual(1, td.BodyStartLocation.Line, "bodystart line");
+//			Assert.AreEqual(16, td.BodyStartLocation.Column, "bodystart col");
+//			Assert.AreEqual(2, td.EndLocation.Line, "end line");
+//			Assert.AreEqual(10, td.EndLocation.Column, "end col");
+//		}
+//		
+//		[Test]
+//		public void VBNetMissingBaseClassTest()
+//		{
+//			// SD2-1499: test that this invalid code doesn't crash
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>("public class test inherits", true);
+//			Assert.AreEqual(0, td.BaseTypes.Count);
+//		}
+//		
+//		[Test]
+//		public void VBNetEnumWithBaseClassDeclarationTest()
+//		{
+//			string program = "Enum TestEnum As Byte\n" +
+//				"End Enum\n";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestEnum", td.Name);
+//			Assert.AreEqual(ClassType.Enum, td.Type);
+//			Assert.AreEqual("System.Byte", td.BaseTypes[0].Type);
+//			Assert.AreEqual(0, td.Children.Count);
+//		}
+//		
+//		[Test]
+//		public void VBNetEnumOnSingleLine()
+//		{
+//			string program = "Enum TestEnum : A : B = 1 : C : End Enum";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestEnum", td.Name);
+//			Assert.AreEqual(ClassType.Enum, td.Type);
+//			Assert.AreEqual(3, td.Children.Count);
+//		}
+//		
+//		[Test]
+//		public void VBNetEnumOnSingleLine2()
+//		{
+//			string program = "Enum TestEnum : A : : B = 1 :: C : End Enum";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestEnum", td.Name);
+//			Assert.AreEqual(ClassType.Enum, td.Type);
+//			Assert.AreEqual(3, td.Children.Count);
+//		}
+//		
+//		
+//		[Test]
+//		public void VBNetEnumWithSystemBaseClassDeclarationTest()
+//		{
+//			string program = "Enum TestEnum As System.UInt16\n" +
+//				"End Enum\n";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestEnum", td.Name);
+//			Assert.AreEqual(ClassType.Enum, td.Type);
+//			Assert.AreEqual("System.UInt16", td.BaseTypes[0].Type);
+//			Assert.AreEqual(0, td.Children.Count);
+//		}
+//		
+//		[Test]
+//		public void VBNetSimpleClassTypeDeclarationWithoutLastNewLineTest()
+//		{
+//			string program = "Class TestClass\n" +
+//				"End Class";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestClass", td.Name);
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual(1, td.StartLocation.Line, "start line");
+//			Assert.AreEqual(2, td.EndLocation.Line, "end line");
+//		}
+//		
+//		[Test]
+//		public void VBNetSimpleClassTypeDeclarationWithColon()
+//		{
+//			string program = "Class TestClass\n" +
+//				" : \n" +
+//				"End Class";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestClass", td.Name);
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//		}
+//		
+//		[Test]
+//		public void VBNetSimplePartialClassTypeDeclarationTest()
+//		{
+//			string program = "Partial Class TestClass\n" +
+//				"End Class\n";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestClass", td.Name);
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual(Modifiers.Partial, td.Modifier);
+//		}
+//		
+//		[Test]
+//		public void VBNetPartialPublicClass()
+//		{
+//			string program = "Partial Public Class TestClass\nEnd Class\n";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(program);
+//			
+//			Assert.AreEqual("TestClass", td.Name);
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual(Modifiers.Partial | Modifiers.Public, td.Modifier);
+//		}
+//		
+//		[Test]
+//		public void VBNetGenericClassTypeDeclarationTest()
+//		{
+//			string declr = @"
+//Public Class Test(Of T)
+//
+//End Class
+//";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
+//			
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual("Test", td.Name);
+//			Assert.AreEqual(Modifiers.Public, td.Modifier);
+//			Assert.AreEqual(0, td.BaseTypes.Count);
+//			Assert.AreEqual(1, td.Templates.Count);
+//			Assert.AreEqual("T", td.Templates[0].Name);
+//		}
+//		
+//		[Test]
+//		public void VBNetGenericClassWithConstraint()
+//		{
+//			string declr = @"
+//Public Class Test(Of T As IMyInterface)
+//
+//End Class
+//";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
+//			
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual("Test", td.Name);
+//			
+//			Assert.AreEqual(1, td.Templates.Count);
+//			Assert.AreEqual("T", td.Templates[0].Name);
+//			Assert.AreEqual("IMyInterface", td.Templates[0].Bases[0].Type);
+//		}
+//		
+//		[Test]
+//		public void VBNetComplexGenericClassTypeDeclarationTest()
+//		{
+//			string declr = @"
+//Public Class Generic(Of T As MyNamespace.IMyInterface, S As {G(Of T()), IAnotherInterface})
+//	Implements System.IComparable
+//
+//End Class
+//";
+//			TypeDeclaration td = ParseUtil.ParseGlobal<TypeDeclaration>(declr);
+//			
+//			Assert.AreEqual(ClassType.Class, td.Type);
+//			Assert.AreEqual("Generic", td.Name);
+//			Assert.AreEqual(Modifiers.Public, td.Modifier);
+//			Assert.AreEqual(1, td.BaseTypes.Count);
+//			Assert.AreEqual("System.IComparable", td.BaseTypes[0].Type);
+//			
+//			Assert.AreEqual(2, td.Templates.Count);
+//			Assert.AreEqual("T", td.Templates[0].Name);
+//			Assert.AreEqual("MyNamespace.IMyInterface", td.Templates[0].Bases[0].Type);
+//			
+//			Assert.AreEqual("S", td.Templates[1].Name);
+//			Assert.AreEqual(2, td.Templates[1].Bases.Count);
+//			Assert.AreEqual("G", td.Templates[1].Bases[0].Type);
+//			Assert.AreEqual(1, td.Templates[1].Bases[0].GenericTypes.Count);
+//			Assert.IsTrue(td.Templates[1].Bases[0].GenericTypes[0].IsArrayType);
+//			Assert.AreEqual("T", td.Templates[1].Bases[0].GenericTypes[0].Type);
+//			Assert.AreEqual(new int[] {0}, td.Templates[1].Bases[0].GenericTypes[0].RankSpecifier);
+//			Assert.AreEqual("IAnotherInterface", td.Templates[1].Bases[1].Type);
+//		}
+//		#endregion
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/UsingDeclarationTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/UsingDeclarationTests.cs
deleted file mode 100644
index 83681327c..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/GlobalScope/UsingDeclarationTests.cs
+++ /dev/null
@@ -1,207 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.IO;
-using ICSharpCode.NRefactory.VB.Parser;
-using ICSharpCode.NRefactory.VB.Ast;
-using NUnit.Framework;
-
-namespace ICSharpCode.NRefactory.VB.Tests.Ast
-{
-	[TestFixture]
-	public class UsingDeclarationTests
-	{
-		void CheckTwoSimpleUsings(CompilationUnit u)
-		{
-			Assert.AreEqual(2, u.Children.Count);
-			Assert.IsTrue(u.Children[0] is UsingDeclaration);
-			UsingDeclaration ud = (UsingDeclaration)u.Children[0];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsTrue(!ud.Usings[0].IsAlias);
-			Assert.AreEqual("System", ud.Usings[0].Name);
-			
-			
-			Assert.IsTrue(u.Children[1] is UsingDeclaration);
-			ud = (UsingDeclaration)u.Children[1];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsTrue(!ud.Usings[0].IsAlias);
-			Assert.AreEqual("My.Name.Space", ud.Usings[0].Name);
-		}
-		
-		void CheckAliases(CompilationUnit u)
-		{
-			Assert.AreEqual(3, u.Children.Count);
-			
-			Assert.IsTrue(u.Children[0] is UsingDeclaration);
-			UsingDeclaration ud = (UsingDeclaration)u.Children[0];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
-			Assert.AreEqual("TESTME", ud.Usings[0].Name);
-			Assert.AreEqual("System", ud.Usings[0].Alias.Type);
-			
-			Assert.IsTrue(u.Children[1] is UsingDeclaration);
-			ud = (UsingDeclaration)u.Children[1];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
-			Assert.AreEqual("myAlias", ud.Usings[0].Name);
-			Assert.AreEqual("My.Name.Space", ud.Usings[0].Alias.Type);
-			
-			Assert.IsTrue(u.Children[2] is UsingDeclaration);
-			ud = (UsingDeclaration)u.Children[2];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsTrue(((Using)ud.Usings[0]).IsAlias);
-			Assert.AreEqual("StringCollection", ud.Usings[0].Name);
-			Assert.AreEqual("System.Collections.Generic.List", ud.Usings[0].Alias.Type);
-			Assert.AreEqual("System.String", ud.Usings[0].Alias.GenericTypes[0].Type);
-		}
-		
-		#region VB.NET
-		[Test]
-		public void VBNetWrongUsingTest()
-		{
-			string program = "Imports\n";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			Assert.IsTrue(parser.Errors.Count > 0);
-			UsingDeclaration u = (UsingDeclaration)parser.CompilationUnit.Children[0];
-			foreach (Using us in u.Usings) {
-				Assert.IsNotNull(us);
-			}
-		}
-		
-		[Test]
-		public void VBNetWrongUsing2Test()
-		{
-			string program = "Imports ,\n";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			Assert.IsTrue(parser.Errors.Count > 0);
-			UsingDeclaration u = (UsingDeclaration)parser.CompilationUnit.Children[0];
-			foreach (Using us in u.Usings) {
-				Assert.IsNotNull(us);
-			}
-		}
-		
-		[Test]
-		public void VBNetDeclarationTest()
-		{
-			string program = "Imports System\n" +
-				"Imports My.Name.Space\n";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			CheckTwoSimpleUsings(parser.CompilationUnit);
-		}
-		
-		[Test]
-		public void VBNetUsingAliasDeclarationTest()
-		{
-			string program = "Imports TESTME=System\n" +
-				"Imports myAlias=My.Name.Space\n" +
-				"Imports StringCollection = System.Collections.Generic.List(Of string)\n";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			CheckAliases(parser.CompilationUnit);
-		}
-		
-		[Test]
-		public void VBNetComplexUsingAliasDeclarationTest()
-		{
-			string program = "Imports NS1, AL=NS2, NS3, AL2=NS4, NS5\n";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			// TODO : Extend test ...
-		}
-		
-		[Test]
-		public void VBNetXmlNamespaceUsingTest()
-		{
-			string program = "Imports <xmlns=\"http://icsharpcode.net/sharpdevelop/avalonedit\">";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			CompilationUnit unit = parser.CompilationUnit;
-			
-			Assert.AreEqual(1, unit.Children.Count);
-			Assert.IsTrue(unit.Children[0] is UsingDeclaration);
-			UsingDeclaration ud = (UsingDeclaration)unit.Children[0];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsFalse(ud.Usings[0].IsAlias);
-			Assert.IsTrue(ud.Usings[0].IsXml);
-			
-			Assert.AreEqual("xmlns", ud.Usings[0].XmlPrefix);
-			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.Usings[0].Name);
-		}
-		
-		[Test]
-		public void VBNetXmlNamespaceWithPrefixUsingTest()
-		{
-			string program = "Imports <xmlns:avalonedit=\"http://icsharpcode.net/sharpdevelop/avalonedit\">";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			CompilationUnit unit = parser.CompilationUnit;
-			
-			Assert.AreEqual(1, unit.Children.Count);
-			Assert.IsTrue(unit.Children[0] is UsingDeclaration);
-			UsingDeclaration ud = (UsingDeclaration)unit.Children[0];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsFalse(ud.Usings[0].IsAlias);
-			Assert.IsTrue(ud.Usings[0].IsXml);
-			
-			Assert.AreEqual("xmlns:avalonedit", ud.Usings[0].XmlPrefix);
-			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.Usings[0].Name);
-		}
-		
-		[Test]
-		public void VBNetXmlNamespaceSingleQuotedUsingTest()
-		{
-			string program = "Imports <xmlns='http://icsharpcode.net/sharpdevelop/avalonedit'>";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			CompilationUnit unit = parser.CompilationUnit;
-			
-			Assert.AreEqual(1, unit.Children.Count);
-			Assert.IsTrue(unit.Children[0] is UsingDeclaration);
-			UsingDeclaration ud = (UsingDeclaration)unit.Children[0];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsFalse(ud.Usings[0].IsAlias);
-			Assert.IsTrue(ud.Usings[0].IsXml);
-			
-			Assert.AreEqual("xmlns", ud.Usings[0].XmlPrefix);
-			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.Usings[0].Name);
-		}
-		
-		[Test]
-		public void VBNetXmlNamespaceSingleQuotedWithPrefixUsingTest()
-		{
-			string program = "Imports <xmlns:avalonedit='http://icsharpcode.net/sharpdevelop/avalonedit'>";
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
-			
-			Assert.AreEqual("", parser.Errors.ErrorOutput);
-			CompilationUnit unit = parser.CompilationUnit;
-			
-			Assert.AreEqual(1, unit.Children.Count);
-			Assert.IsTrue(unit.Children[0] is UsingDeclaration);
-			UsingDeclaration ud = (UsingDeclaration)unit.Children[0];
-			Assert.AreEqual(1, ud.Usings.Count);
-			Assert.IsFalse(ud.Usings[0].IsAlias);
-			Assert.IsTrue(ud.Usings[0].IsXml);
-			
-			Assert.AreEqual("xmlns:avalonedit", ud.Usings[0].XmlPrefix);
-			Assert.AreEqual("http://icsharpcode.net/sharpdevelop/avalonedit", ud.Usings[0].Name);
-		}
-		#endregion
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs
deleted file mode 100644
index 50f72fd0d..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/LocationAssignmentCheckVisitor.cs
+++ /dev/null
@@ -1,26 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.NRefactory.VB.Ast;
-using ICSharpCode.NRefactory.VB.Visitors;
-using NUnit.Framework;
-
-namespace ICSharpCode.NRefactory.VB.Tests.Ast
-{
-	public class LocationAssignmentCheckVisitor : NodeTrackingAstVisitor
-	{
-		protected override void BeginVisit(INode node)
-		{
-			if (node is CompilationUnit)
-				return;
-			if (node is INullable && ((INullable)node).IsNull)
-				return;
-			if (node is TypeReference)
-				return;
-			
-			Assert.IsFalse(node.StartLocation.IsEmpty, "StartLocation of {0}", node);
-			Assert.IsFalse(node.EndLocation.IsEmpty, "EndLocation of {0}", node);
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/ParseUtil.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/ParseUtil.cs
index 4ed9d2197..5704c031e 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/ParseUtil.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/ParseUtil.cs
@@ -3,90 +3,106 @@
 
 using System;
 using System.IO;
-using ICSharpCode.NRefactory.VB.Parser;
+using System.Linq;
+
+using ICSharpCode.NRefactory.PatternMatching;
 using ICSharpCode.NRefactory.VB.Ast;
+using ICSharpCode.NRefactory.VB.Parser;
 using NUnit.Framework;
 
 namespace ICSharpCode.NRefactory.VB.Tests.Ast
 {
 	public class ParseUtil
 	{
-		public static T ParseGlobal<T>(string program) where T : INode
-		{
-			return ParseGlobal<T>(program, false);
-		}
-		
-		public static T ParseGlobal<T>(string program, bool expectErrors) where T : INode
+		public static T ParseGlobal<T>(string code, bool expectErrors = false) where T : AstNode
 		{
-			VBParser parser = ParserFactory.CreateParser(new StringReader(program));
-			parser.Parse();
+			VBParser parser = new VBParser();
+			CompilationUnit cu = parser.Parse(new StringReader(code));
 			
-			if (expectErrors)
-				Assert.IsFalse(parser.Errors.ErrorOutput.Length == 0, "Expected errors, but operation completed successfully");
-			else
-				Assert.AreEqual("", parser.Errors.ErrorOutput);
-			
-			Assert.IsNotNull(parser.CompilationUnit);
-			Assert.IsNotNull(parser.CompilationUnit.Children);
-			Assert.IsNotNull(parser.CompilationUnit.Children[0]);
-			Assert.AreEqual(1, parser.CompilationUnit.Children.Count);
+			Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
 			
+			AstNode node = cu.Children.Single();
 			Type type = typeof(T);
-			Assert.IsTrue(type.IsAssignableFrom(parser.CompilationUnit.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parser.CompilationUnit.Children[0].GetType(), type, parser.CompilationUnit.Children[0]));
-			
-			parser.CompilationUnit.AcceptVisitor(new CheckParentVisitor(), null);
-			// TODO fix Locations
-//			parser.CompilationUnit.AcceptChildren(new LocationAssignmentCheckVisitor(), null);
-			
-			return (T)parser.CompilationUnit.Children[0];
+			Assert.IsTrue(type.IsAssignableFrom(node.GetType()), String.Format("Parsed node was {0} instead of {1} ({2})", node.GetType(), type, node));
+			return (T)node;
 		}
 		
-		public static T ParseTypeMember<T>(string typeMember, bool expectErrors) where T : INode
+		public static void AssertGlobal(string code, AstNode expectedNode)
 		{
-			TypeDeclaration td = ParseGlobal<TypeDeclaration>("Class TestClass\n " + typeMember + "\n End Class\n", expectErrors);
-			Assert.AreEqual(1, td.Children.Count);
-			Type type = typeof(T);
-			Assert.IsTrue(type.IsAssignableFrom(td.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", td.GetType(), type, td));
-			return (T)td.Children[0];
+			var node = ParseGlobal<AstNode>(code);
+			if (!expectedNode.IsMatch(node)) {
+				Assert.Fail("Expected '{0}' but was '{1}'", ToVB(expectedNode), ToVB(node));
+			}
 		}
 		
-		public static T ParseTypeMember<T>(string typeMember) where T : INode
-		{
-			return ParseTypeMember<T>(typeMember, false);
-		}
+//		public static T ParseStatement<T>(string stmt, bool expectErrors = false) where T : AstNode
+//		{
+//			VBParser parser = new VBParser();
+//			var statements = parser.ParseStatements(new StringReader(stmt));
+//			
+//			Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
+//			
+//			AstNode statement = statements.Single();
+//			Type type = typeof(T);
+//			Assert.IsTrue(type.IsAssignableFrom(statement.GetType()), String.Format("Parsed statement was {0} instead of {1} ({2})", statement.GetType(), type, statement));
+//			return (T)statement;
+//		}
+//		
+//		public static void AssertStatement(string code, VB.Ast.Statement expectedStmt)
+//		{
+//			var stmt = ParseStatement<VB.Ast.Statement>(code);
+//			if (!expectedStmt.IsMatch(stmt)) {
+//				Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedStmt), ToCSharp(stmt));
+//			}
+//		}
+//		
+//		public static T ParseExpression<T>(string expr, bool expectErrors = false) where T : AstNode
+//		{
+//			VBParser parser = new VBParser();
+//			AstNode parsedExpression = parser.ParseExpression(new StringReader(expr));
+//			
+//			Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
+//			if (expectErrors && parsedExpression == null)
+//				return default (T);
+//			Type type = typeof(T);
+//			Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression));
+//			return (T)parsedExpression;
+//		}
+//		
+//		public static void AssertExpression(string code, VB.Ast.Expression expectedExpr)
+//		{
+//			var expr = ParseExpression<CSharp.Expression>(code);
+//			if (!expectedExpr.IsMatch(expr)) {
+//				Assert.Fail("Expected '{0}' but was '{1}'", ToCSharp(expectedExpr), ToCSharp(expr));
+//			}
+//		}
+//		
+//		public static T ParseTypeMember<T>(string expr, bool expectErrors = false) where T : AttributedNode
+//		{
+//			VBParser parser = new VBParser();
+//			var members = parser.ParseTypeMembers(new StringReader(expr));
+//			
+//			Assert.AreEqual(expectErrors, parser.HasErrors, "HasErrors");
+//			
+//			AttributedNode m = members.Single();
+//			Type type = typeof(T);
+//			Assert.IsTrue(type.IsAssignableFrom(m.GetType()), String.Format("Parsed member was {0} instead of {1} ({2})", m.GetType(), type, m));
+//			return (T)m;
+//		}
+//		
+//		public static void AssertTypeMember(string code, VB.Ast.AttributedNode expectedMember)
+//		{
+//			var member = ParseTypeMember<VB.Ast.AttributedNode>(code);
+//			if (!expectedMember.IsMatch(member)) {
+//				Assert.Fail("Expected '{0}' but was '{1}'", ToVB(expectedMember), ToVB(member));
+//			}
+//		}
 		
-		public static T ParseStatement<T>(string statement, bool expectErrors) where T : INode
+		static string ToVB(AstNode node)
 		{
-			MethodDeclaration md = ParseTypeMember<MethodDeclaration>("Sub A()\n " + statement + "\nEnd Sub\n", expectErrors);
-			Assert.AreEqual(1, md.Body.Children.Count);
-			Type type = typeof(T);
-			Assert.IsTrue(type.IsAssignableFrom(md.Body.Children[0].GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", md.GetType(), type, md));
-			return (T)md.Body.Children[0];
-		}
-		
-		public static T ParseStatement<T>(string statement) where T : INode
-		{
-			return ParseStatement<T>(statement, false);
-		}
-		
-		public static T ParseExpression<T>(string expr) where T : INode
-		{
-			return ParseExpression<T>(expr, false);
-		}
-		
-		public static T ParseExpression<T>(string expr, bool expectErrors) where T : INode
-		{
-			VBParser parser = ParserFactory.CreateParser(new StringReader(expr));
-			INode parsedExpression = parser.ParseExpression();
-			if (expectErrors)
-				Assert.IsFalse(parser.Errors.ErrorOutput.Length == 0, "Expected errors, but operation completed successfully");
-			else
-				Assert.AreEqual("", parser.Errors.ErrorOutput);
-			// TODO fix Locations
-//			parsedExpression.AcceptVisitor(new LocationAssignmentCheckVisitor(), null);
-			Type type = typeof(T);
-			Assert.IsTrue(type.IsAssignableFrom(parsedExpression.GetType()), String.Format("Parsed expression was {0} instead of {1} ({2})", parsedExpression.GetType(), type, parsedExpression));
-			return (T)parsedExpression;
+			StringWriter w = new StringWriter();
+			node.AcceptVisitor(new OutputVisitor(w, new VBFormattingOptions()), null);
+			return w.ToString();
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/SnippetParserTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/SnippetParserTests.cs
index 40da76cae..bf64c982b 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/SnippetParserTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/SnippetParserTests.cs
@@ -10,13 +10,13 @@ namespace ICSharpCode.NRefactory.VB.Tests
 	[TestFixture]
 	public class SnippetParserTests
 	{
-		[Test]
-		public void InvalidExpressionSyntax()
-		{
-			// SD2-1584: ensure we don't crash on this invalid VB code
-			SnippetParser parser = new SnippetParser();
-			INode node = parser.Parse("i == 5");
-			Assert.IsTrue(parser.Errors.Count > 0);
-		}
+//		[Test]
+//		public void InvalidExpressionSyntax()
+//		{
+//			// SD2-1584: ensure we don't crash on this invalid VB code
+//			SnippetParser parser = new SnippetParser();
+//			INode node = parser.Parse("i == 5");
+//			Assert.IsTrue(parser.Errors.Count > 0);
+//		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Statements/SwitchStatementTests.cs b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Statements/SwitchStatementTests.cs
index c7dcb48fa..39f4a47a8 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Statements/SwitchStatementTests.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB.Tests/Parser/Statements/SwitchStatementTests.cs
@@ -17,7 +17,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		public void VBSwitchStatementTest()
 		{
 			SwitchStatement switchStmt = ParseUtil.ParseStatement<SwitchStatement>("Select Case a\n Case 4, 5\n Case 6\n Case Else\n End Select");
-			Assert.AreEqual("a", ((IdentifierExpression)switchStmt.SwitchExpression).Identifier);
+			Assert.AreEqual("a", ((SimpleNameExpression)switchStmt.SwitchExpression).Identifier);
 			// TODO: Extend test
 		}
 		
@@ -25,7 +25,7 @@ namespace ICSharpCode.NRefactory.VB.Tests.Ast
 		public void InvalidVBSwitchStatementTest()
 		{
 			SwitchStatement switchStmt = ParseUtil.ParseStatement<SwitchStatement>("Select Case a\n Case \n End Select", true);
-			Assert.AreEqual("a", ((IdentifierExpression)switchStmt.SwitchExpression).Identifier);
+			Assert.AreEqual("a", ((SimpleNameExpression)switchStmt.SwitchExpression).Identifier);
 			SwitchSection sec = switchStmt.SwitchSections[0];
 			Assert.AreEqual(0, sec.SwitchLabels.Count);
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/AbstractNode.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AbstractNode.cs
deleted file mode 100644
index 2347f4f05..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/AbstractNode.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Text;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public abstract class AbstractNode : INode
-	{
-		List<INode> children = new List<INode>();
-		
-		public INode Parent { get; set; }
-		public Location StartLocation { get; set; }
-		public Location EndLocation { get; set; }
-		public object UserData { get; set; }
-		
-		public List<INode> Children {
-			get {
-				return children;
-			}
-			set {
-				Debug.Assert(value != null);
-				children = value;
-			}
-		}
-		
-		public virtual void AddChild(INode childNode)
-		{
-			Debug.Assert(childNode != null);
-			childNode.Parent = this;
-			children.Add(childNode);
-		}
-		
-		public abstract object AcceptVisitor(IAstVisitor visitor, object data);
-		
-		public virtual object AcceptChildren(IAstVisitor visitor, object data)
-		{
-			foreach (INode child in children) {
-				Debug.Assert(child != null);
-				child.AcceptVisitor(visitor, data);
-			}
-			return data;
-		}
-		
-		public static string GetCollectionString(ICollection collection)
-		{
-			StringBuilder output = new StringBuilder();
-			output.Append('{');
-			
-			if (collection != null) {
-				IEnumerator en = collection.GetEnumerator();
-				bool isFirst = true;
-				while (en.MoveNext()) {
-					if (!isFirst) {
-						output.Append(", ");
-					} else {
-						isFirst = false;
-					}
-					output.Append(en.Current == null ? "<null>" : en.Current.ToString());
-				}
-			} else {
-				return "null";
-			}
-			
-			output.Append('}');
-			return output.ToString();
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstLocation.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstLocation.cs
new file mode 100644
index 000000000..4a3a1bc68
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstLocation.cs
@@ -0,0 +1,137 @@
+//
+// DomLocation.cs
+//
+// Author:
+//   Mike Krüger <mkrueger@novell.com>
+//
+// Copyright (C) 2008 Novell, Inc (http://www.novell.com)
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	[Serializable]
+	public struct AstLocation : IComparable<AstLocation>, IEquatable<AstLocation>
+	{
+		public static readonly AstLocation Empty = new AstLocation(0, 0);
+		
+		readonly int line, column;
+		
+		public AstLocation (int line, int column)
+		{
+			this.line   = line;
+			this.column = column;
+		}
+		
+		public bool IsEmpty {
+			get {
+				return line <= 0;
+			}
+		}
+		
+		public int Line {
+			get { return line; }
+		}
+		
+		public int Column {
+			get { return column; }
+		}
+		
+		public override bool Equals (object obj)
+		{
+			if (!(obj is AstLocation))
+				return false;
+			return (AstLocation)obj == this;
+		}
+		
+		public override int GetHashCode ()
+		{
+			unchecked {
+				return line + column * 5000;
+			}
+		}
+		
+		public bool Equals (AstLocation other)
+		{
+			return other == this;
+		}
+		
+		public int CompareTo (AstLocation other)
+		{
+			if (this == other)
+				return 0;
+			if (this < other)
+				return -1;
+			return 1;
+		}
+		
+		public override string ToString ()
+		{
+			return String.Format ("(Line {0}, Column {1})", Line, Column);
+		}
+
+		public static AstLocation FromInvariantString (string invariantString)
+		{
+			if (string.Equals(invariantString, "EMPTY", StringComparison.OrdinalIgnoreCase))
+				return AstLocation.Empty;
+			string[] splits = invariantString.Split (',', '/');
+			if (splits.Length == 2)
+				return new AstLocation (Int32.Parse (splits[0]), Int32.Parse (splits[1]));
+			return AstLocation.Empty;
+		}
+		
+		public string ToInvariantString ()
+		{
+			if (IsEmpty)
+				return "Empty";
+			return String.Format ("{0}/{1}", line, column);
+		}
+		
+		public static bool operator==(AstLocation left, AstLocation right)
+		{
+			return left.line == right.line && left.column == right.column;
+		}
+		
+		public static bool operator!=(AstLocation left, AstLocation right)
+		{
+			return left.line != right.line || left.column != right.column;
+		}
+		
+		public static bool operator<(AstLocation left, AstLocation right)
+		{
+			return left.line < right.line || left.line == right.line && left.column < right.column;
+		}
+		public static bool operator>(AstLocation left, AstLocation right)
+		{
+			return left.line > right.line || left.line == right.line && left.column > right.column;
+		}
+		public static bool operator<=(AstLocation left, AstLocation right)
+		{
+			return !(left > right);
+		}
+		public static bool operator>=(AstLocation left, AstLocation right)
+		{
+			return !(left < right);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstNode.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstNode.cs
new file mode 100644
index 000000000..d66abad92
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstNode.cs
@@ -0,0 +1,730 @@
+// 
+// AstNode.cs
+//
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2009 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using ICSharpCode.NRefactory.PatternMatching;
+using ICSharpCode.NRefactory.VB.Ast;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	public abstract class AstNode : PatternMatching.INode
+	{
+		#region Null
+		public static readonly AstNode Null = new NullAstNode ();
+		
+		sealed class NullAstNode : AstNode
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default (S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		#endregion
+		
+		#region PatternPlaceholder
+		public static implicit operator AstNode(PatternMatching.Pattern pattern)
+		{
+			return pattern != null ? new PatternPlaceholder(pattern) : null;
+		}
+		
+		sealed class PatternPlaceholder : AstNode, PatternMatching.INode
+		{
+			readonly PatternMatching.Pattern child;
+			
+			public PatternPlaceholder(PatternMatching.Pattern child)
+			{
+				this.child = child;
+			}
+			
+			public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+			{
+				return visitor.VisitPatternPlaceholder(this, child, data);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return child.DoMatch(other, match);
+			}
+			
+			bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo)
+			{
+				return child.DoMatchCollection(role, pos, match, backtrackingInfo);
+			}
+		}
+		#endregion
+		
+		AstNode parent;
+		AstNode prevSibling;
+		AstNode nextSibling;
+		AstNode firstChild;
+		AstNode lastChild;
+		Role role = RootRole;
+		
+		public virtual bool IsNull {
+			get {
+				return false;
+			}
+		}
+		
+		public virtual AstLocation StartLocation {
+			get {
+				var child = firstChild;
+				if (child == null)
+					return AstLocation.Empty;
+				return child.StartLocation;
+			}
+		}
+		
+		public virtual AstLocation EndLocation {
+			get {
+				var child = lastChild;
+				if (child == null)
+					return AstLocation.Empty;
+				return child.EndLocation;
+			}
+		}
+		
+		public AstNode Parent {
+			get { return parent; }
+		}
+		
+		public Role Role {
+			get { return role; }
+		}
+		
+		public AstNode NextSibling {
+			get { return nextSibling; }
+		}
+		
+		public AstNode PrevSibling {
+			get { return prevSibling; }
+		}
+		
+		public AstNode FirstChild {
+			get { return firstChild; }
+		}
+		
+		public AstNode LastChild {
+			get { return lastChild; }
+		}
+		
+		public IEnumerable<AstNode> Children {
+			get {
+				AstNode next;
+				for (AstNode cur = firstChild; cur != null; cur = next) {
+					Debug.Assert(cur.parent == this);
+					// Remember next before yielding cur.
+					// This allows removing/replacing nodes while iterating through the list.
+					next = cur.nextSibling;
+					yield return cur;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Gets the ancestors of this node (excluding this node itself)
+		/// </summary>
+		public IEnumerable<AstNode> Ancestors {
+			get {
+				for (AstNode cur = parent; cur != null; cur = cur.parent) {
+					yield return cur;
+				}
+			}
+		}
+		
+		/// <summary>
+		/// Gets all descendants of this node (excluding this node itself).
+		/// </summary>
+		public IEnumerable<AstNode> Descendants {
+			get {
+				return Utils.TreeTraversal.PreOrder(this.Children, n => n.Children);
+			}
+		}
+		
+		/// <summary>
+		/// Gets all descendants of this node (including this node itself).
+		/// </summary>
+		public IEnumerable<AstNode> DescendantsAndSelf {
+			get {
+				return Utils.TreeTraversal.PreOrder(this, n => n.Children);
+			}
+		}
+		
+		/// <summary>
+		/// Gets the first child with the specified role.
+		/// Returns the role's null object if the child is not found.
+		/// </summary>
+		public T GetChildByRole<T>(Role<T> role) where T : AstNode
+		{
+			if (role == null)
+				throw new ArgumentNullException("role");
+			for (var cur = firstChild; cur != null; cur = cur.nextSibling) {
+				if (cur.role == role)
+					return (T)cur;
+			}
+			return role.NullObject;
+		}
+		
+		public AstNodeCollection<T> GetChildrenByRole<T>(Role<T> role) where T : AstNode
+		{
+			return new AstNodeCollection<T>(this, role);
+		}
+		
+		protected void SetChildByRole<T>(Role<T> role, T newChild) where T : AstNode
+		{
+			AstNode oldChild = GetChildByRole(role);
+			if (oldChild.IsNull)
+				AddChild(newChild, role);
+			else
+				oldChild.ReplaceWith(newChild);
+		}
+		
+		public void AddChild<T>(T child, Role<T> role) where T : AstNode
+		{
+			if (role == null)
+				throw new ArgumentNullException("role");
+			if (child == null || child.IsNull)
+				return;
+			if (this.IsNull)
+				throw new InvalidOperationException("Cannot add children to null nodes");
+			if (child.parent != null)
+				throw new ArgumentException ("Node is already used in another tree.", "child");
+			AddChildUnsafe(child, role);
+		}
+		
+		internal void AddChildUntyped(AstNode child, Role role)
+		{
+			if (role == null)
+				throw new ArgumentNullException("role");
+			if (child == null || child.IsNull)
+				return;
+			if (this.IsNull)
+				throw new InvalidOperationException("Cannot add children to null nodes");
+			if (child.parent != null)
+				throw new ArgumentException ("Node is already used in another tree.", "child");
+			AddChildUnsafe(child, role);
+		}
+		
+		/// <summary>
+		/// Adds a child without performing any safety checks.
+		/// </summary>
+		void AddChildUnsafe(AstNode child, Role role)
+		{
+			child.parent = this;
+			child.role = role;
+			if (firstChild == null) {
+				lastChild = firstChild = child;
+			} else {
+				lastChild.nextSibling = child;
+				child.prevSibling = lastChild;
+				lastChild = child;
+			}
+		}
+		
+		public void InsertChildBefore<T>(AstNode nextSibling, T child, Role<T> role) where T : AstNode
+		{
+			if (role == null)
+				throw new ArgumentNullException("role");
+			if (nextSibling == null || nextSibling.IsNull) {
+				AddChild(child, role);
+				return;
+			}
+			
+			if (child == null || child.IsNull)
+				return;
+			if (child.parent != null)
+				throw new ArgumentException ("Node is already used in another tree.", "child");
+			if (nextSibling.parent != this)
+				throw new ArgumentException ("NextSibling is not a child of this node.", "nextSibling");
+			// No need to test for "Cannot add children to null nodes",
+			// as there isn't any valid nextSibling in null nodes.
+			InsertChildBeforeUnsafe(nextSibling, child, role);
+		}
+		
+		
+		void InsertChildBeforeUnsafe(AstNode nextSibling, AstNode child, Role role)
+		{
+			child.parent = this;
+			child.role = role;
+			child.nextSibling = nextSibling;
+			child.prevSibling = nextSibling.prevSibling;
+			
+			if (nextSibling.prevSibling != null) {
+				Debug.Assert(nextSibling.prevSibling.nextSibling == nextSibling);
+				nextSibling.prevSibling.nextSibling = child;
+			} else {
+				Debug.Assert(firstChild == nextSibling);
+				firstChild = child;
+			}
+			nextSibling.prevSibling = child;
+		}
+		
+		public void InsertChildAfter<T>(AstNode prevSibling, T child, Role<T> role) where T : AstNode
+		{
+			InsertChildBefore((prevSibling == null || prevSibling.IsNull) ? firstChild : prevSibling.nextSibling, child, role);
+		}
+		
+		/// <summary>
+		/// Removes this node from its parent.
+		/// </summary>
+		public void Remove()
+		{
+			if (parent != null) {
+				if (prevSibling != null) {
+					Debug.Assert(prevSibling.nextSibling == this);
+					prevSibling.nextSibling = nextSibling;
+				} else {
+					Debug.Assert(parent.firstChild == this);
+					parent.firstChild = nextSibling;
+				}
+				if (nextSibling != null) {
+					Debug.Assert(nextSibling.prevSibling == this);
+					nextSibling.prevSibling = prevSibling;
+				} else {
+					Debug.Assert(parent.lastChild == this);
+					parent.lastChild = prevSibling;
+				}
+				parent = null;
+				role = Roles.Root;
+				prevSibling = null;
+				nextSibling = null;
+			}
+		}
+		
+		/// <summary>
+		/// Replaces this node with the new node.
+		/// </summary>
+		public void ReplaceWith(AstNode newNode)
+		{
+			if (newNode == null || newNode.IsNull) {
+				Remove();
+				return;
+			}
+			if (newNode == this)
+				return; // nothing to do...
+			if (parent == null) {
+				throw new InvalidOperationException(this.IsNull ? "Cannot replace the null nodes" : "Cannot replace the root node");
+			}
+			// Because this method doesn't statically check the new node's type with the role,
+			// we perform a runtime test:
+			if (!role.IsValid(newNode)) {
+				throw new ArgumentException (string.Format("The new node '{0}' is not valid in the role {1}", newNode.GetType().Name, role.ToString()), "newNode");
+			}
+			if (newNode.parent != null) {
+				// newNode is used within this tree?
+				if (newNode.Ancestors.Contains(this)) {
+					// e.g. "parenthesizedExpr.ReplaceWith(parenthesizedExpr.Expression);"
+					// enable automatic removal
+					newNode.Remove();
+				} else {
+					throw new ArgumentException ("Node is already used in another tree.", "newNode");
+				}
+			}
+			
+			newNode.parent = parent;
+			newNode.role = role;
+			newNode.prevSibling = prevSibling;
+			newNode.nextSibling = nextSibling;
+			if (parent != null) {
+				if (prevSibling != null) {
+					Debug.Assert(prevSibling.nextSibling == this);
+					prevSibling.nextSibling = newNode;
+				} else {
+					Debug.Assert(parent.firstChild == this);
+					parent.firstChild = newNode;
+				}
+				if (nextSibling != null) {
+					Debug.Assert(nextSibling.prevSibling == this);
+					nextSibling.prevSibling = newNode;
+				} else {
+					Debug.Assert(parent.lastChild == this);
+					parent.lastChild = newNode;
+				}
+				parent = null;
+				prevSibling = null;
+				nextSibling = null;
+				role = Roles.Root;
+			}
+		}
+		
+		public AstNode ReplaceWith(Func<AstNode, AstNode> replaceFunction)
+		{
+			if (replaceFunction == null)
+				throw new ArgumentNullException("replaceFunction");
+			if (parent == null) {
+				throw new InvalidOperationException(this.IsNull ? "Cannot replace the null nodes" : "Cannot replace the root node");
+			}
+			AstNode oldParent = parent;
+			AstNode oldSuccessor = nextSibling;
+			Role oldRole = role;
+			Remove();
+			AstNode replacement = replaceFunction(this);
+			if (oldSuccessor != null && oldSuccessor.parent != oldParent)
+				throw new InvalidOperationException("replace function changed nextSibling of node being replaced?");
+			if (!(replacement == null || replacement.IsNull)) {
+				if (replacement.parent != null)
+					throw new InvalidOperationException("replace function must return the root of a tree");
+				if (!oldRole.IsValid(replacement)) {
+					throw new InvalidOperationException (string.Format("The new node '{0}' is not valid in the role {1}", replacement.GetType().Name, oldRole.ToString()));
+				}
+				
+				if (oldSuccessor != null)
+					oldParent.InsertChildBeforeUnsafe(oldSuccessor, replacement, oldRole);
+				else
+					oldParent.AddChildUnsafe(replacement, oldRole);
+			}
+			return replacement;
+		}
+		
+		/// <summary>
+		/// Clones the whole subtree starting at this AST node.
+		/// </summary>
+		/// <remarks>Annotations are copied over to the new nodes; and any annotations implementating ICloneable will be cloned.</remarks>
+		public AstNode Clone()
+		{
+			AstNode copy = (AstNode)MemberwiseClone();
+			// First, reset the shallow pointer copies
+			copy.parent = null;
+			copy.role = Roles.Root;
+			copy.firstChild = null;
+			copy.lastChild = null;
+			copy.prevSibling = null;
+			copy.nextSibling = null;
+			
+			// Then perform a deep copy:
+			for (AstNode cur = firstChild; cur != null; cur = cur.nextSibling) {
+				copy.AddChildUnsafe(cur.Clone(), cur.role);
+			}
+			
+			// Finally, clone the annotation, if necessary
+			ICloneable annotations = copy.annotations as ICloneable; // read from copy (for thread-safety)
+			if (annotations != null)
+				copy.annotations = annotations.Clone();
+			
+			return copy;
+		}
+		
+		#region Annotation support
+		// Annotations: points either null (no annotations), to the single annotation,
+		// or to an AnnotationList.
+		// Once it is pointed at an AnnotationList, it will never change (this allows thread-safety support by locking the list)
+		object annotations;
+		
+		sealed class AnnotationList : List<object>, ICloneable
+		{
+			// There are two uses for this custom list type:
+			// 1) it's private, and thus (unlike List<object>) cannot be confused with real annotations
+			// 2) It allows us to simplify the cloning logic by making the list behave the same as a clonable annotation.
+			public AnnotationList(int initialCapacity) : base(initialCapacity)
+			{
+			}
+			
+			public object Clone()
+			{
+				lock (this) {
+					AnnotationList copy = new AnnotationList(this.Count);
+					for (int i = 0; i < this.Count; i++) {
+						object obj = this[i];
+						ICloneable c = obj as ICloneable;
+						copy.Add(c != null ? c.Clone() : obj);
+					}
+					return copy;
+				}
+			}
+		}
+		
+		public void AddAnnotation(object annotation)
+		{
+			if (annotation == null)
+				throw new ArgumentNullException("annotation");
+			if (this.IsNull)
+				throw new InvalidOperationException("Cannot add annotations to the null node");
+		retry: // Retry until successful
+			object oldAnnotation = Interlocked.CompareExchange(ref this.annotations, annotation, null);
+			if (oldAnnotation == null) {
+				return; // we successfully added a single annotation
+			}
+			AnnotationList list = oldAnnotation as AnnotationList;
+			if (list == null) {
+				// we need to transform the old annotation into a list
+				list = new AnnotationList(4);
+				list.Add(oldAnnotation);
+				list.Add(annotation);
+				if (Interlocked.CompareExchange(ref this.annotations, list, oldAnnotation) != oldAnnotation) {
+					// the transformation failed (some other thread wrote to this.annotations first)
+					goto retry;
+				}
+			} else {
+				// once there's a list, use simple locking
+				lock (list) {
+					list.Add(annotation);
+				}
+			}
+		}
+		
+		public void RemoveAnnotations<T>() where T : class
+		{
+		retry: // Retry until successful
+			object oldAnnotations = this.annotations;
+			AnnotationList list = oldAnnotations as AnnotationList;
+			if (list != null) {
+				lock (list)
+					list.RemoveAll(obj => obj is T);
+			} else if (oldAnnotations is T) {
+				if (Interlocked.CompareExchange(ref this.annotations, null, oldAnnotations) != oldAnnotations) {
+					// Operation failed (some other thread wrote to this.annotations first)
+					goto retry;
+				}
+			}
+		}
+		
+		public void RemoveAnnotations(Type type)
+		{
+			if (type == null)
+				throw new ArgumentNullException("type");
+		retry: // Retry until successful
+			object oldAnnotations = this.annotations;
+			AnnotationList list = oldAnnotations as AnnotationList;
+			if (list != null) {
+				lock (list)
+					list.RemoveAll(obj => type.IsInstanceOfType(obj));
+			} else if (type.IsInstanceOfType(oldAnnotations)) {
+				if (Interlocked.CompareExchange(ref this.annotations, null, oldAnnotations) != oldAnnotations) {
+					// Operation failed (some other thread wrote to this.annotations first)
+					goto retry;
+				}
+			}
+		}
+		
+		public T Annotation<T>() where T: class
+		{
+			object annotations = this.annotations;
+			AnnotationList list = annotations as AnnotationList;
+			if (list != null) {
+				lock (list) {
+					foreach (object obj in list) {
+						T t = obj as T;
+						if (t != null)
+							return t;
+					}
+					return null;
+				}
+			} else {
+				return annotations as T;
+			}
+		}
+		
+		public object Annotation(Type type)
+		{
+			if (type == null)
+				throw new ArgumentNullException("type");
+			object annotations = this.annotations;
+			AnnotationList list = annotations as AnnotationList;
+			if (list != null) {
+				lock (list) {
+					foreach (object obj in list) {
+						if (type.IsInstanceOfType(obj))
+							return obj;
+					}
+				}
+			} else {
+				if (type.IsInstanceOfType(annotations))
+					return annotations;
+			}
+			return null;
+		}
+		
+		/// <summary>
+		/// Gets all annotations stored on this AstNode.
+		/// </summary>
+		public IEnumerable<object> Annotations {
+			get {
+				object annotations = this.annotations;
+				AnnotationList list = annotations as AnnotationList;
+				if (list != null) {
+					lock (list) {
+						return list.ToArray();
+					}
+				} else {
+					if (annotations != null)
+						return new object[] { annotations };
+					else
+						return Enumerable.Empty<object>();
+				}
+			}
+		}
+		#endregion
+		
+		public abstract S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data);
+		
+		#region Pattern Matching
+		protected static bool MatchString(string name1, string name2)
+		{
+			return string.IsNullOrEmpty(name1) || string.Equals(name1, name2, StringComparison.OrdinalIgnoreCase);
+		}
+		
+		protected static bool MatchStringXml(string name1, string name2)
+		{
+			return string.IsNullOrEmpty(name1) || string.Equals(name1, name2, StringComparison.Ordinal);
+		}
+		
+		protected internal abstract bool DoMatch(AstNode other, PatternMatching.Match match);
+		
+		bool PatternMatching.INode.DoMatch(PatternMatching.INode other, PatternMatching.Match match)
+		{
+			AstNode o = other as AstNode;
+			// try matching if other is null, or if other is an AstNode
+			return (other == null || o != null) && DoMatch(o, match);
+		}
+		
+		bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo)
+		{
+			AstNode o = pos as AstNode;
+			return (pos == null || o != null) && DoMatch (o, match);
+		}
+		
+		PatternMatching.INode PatternMatching.INode.NextSibling {
+			get { return nextSibling; }
+		}
+		
+		PatternMatching.INode PatternMatching.INode.FirstChild {
+			get { return firstChild; }
+		}
+		#endregion
+		
+		public AstNode GetNextNode ()
+		{
+			if (NextSibling != null)
+				return NextSibling;
+			if (Parent != null)
+				return Parent.GetNextNode ();
+			return null;
+		}
+
+		public AstNode GetPrevNode ()
+		{
+			if (PrevSibling != null)
+				return PrevSibling;
+			if (Parent != null)
+				return Parent.GetPrevNode ();
+			return null;
+		}
+		
+		// filters all non VB nodes (comments, white spaces or pre processor directives)
+		public AstNode GetVBNodeBefore (AstNode node)
+		{
+			var n = node.PrevSibling;
+			while (n != null) {
+				if (n.Role != Roles.Comment)
+					return n;
+				n = n.GetPrevNode ();
+			}
+			return null;
+		}
+		
+		// the Root role must be available when creating the null nodes, so we can't put it in the Roles class
+		static readonly Role<AstNode> RootRole = new Role<AstNode>("Root");
+		
+		public static class Roles
+		{
+			/// <summary>
+			/// Root of an abstract syntax tree.
+			/// </summary>
+			public static readonly Role<AstNode> Root = RootRole;
+			
+			// some pre defined constants for common roles
+			public static readonly Role<Identifier> Identifier = new Role<Identifier>("Identifier", Ast.Identifier.Null);
+			public static readonly Role<XmlIdentifier> XmlIdentifier = new Role<XmlIdentifier>("XmlIdentifier", Ast.XmlIdentifier.Null);
+			public static readonly Role<XmlLiteralString> XmlLiteralString = new Role<XmlLiteralString>("XmlLiteralString", Ast.XmlLiteralString.Null);
+			
+//			public static readonly Role<BlockStatement> Body = new Role<BlockStatement>("Body", CSharp.BlockStatement.Null);
+			public static readonly Role<ParameterDeclaration> Parameter = new Role<ParameterDeclaration>("Parameter");
+			public static readonly Role<Expression> Argument = new Role<Expression>("Argument", Ast.Expression.Null);
+			public static readonly Role<AstType> Type = new Role<AstType>("Type", AstType.Null);
+			public static readonly Role<Expression> Expression = new Role<Expression>("Expression", Ast.Expression.Null);
+//			public static readonly Role<Expression> TargetExpression = new Role<Expression>("Target", CSharp.Expression.Null);
+//			public readonly static Role<Expression> Condition = new Role<Expression>("Condition", CSharp.Expression.Null);
+//
+			public static readonly Role<TypeParameterDeclaration> TypeParameter = new Role<TypeParameterDeclaration>("TypeParameter");
+			public static readonly Role<AstType> TypeArgument = new Role<AstType>("TypeArgument", AstType.Null);
+//			public static readonly Role<VariableInitializer> Variable = new Role<VariableInitializer>("Variable");
+//			public static readonly Role<Statement> EmbeddedStatement = new Role<Statement>("EmbeddedStatement", CSharp.Statement.Null);
+//
+			public static readonly Role<VBTokenNode> Keyword = new Role<VBTokenNode>("Keyword", VBTokenNode.Null);
+//			public static readonly Role<VBTokenNode> InKeyword = new Role<VBTokenNode>("InKeyword", VBTokenNode.Null);
+			
+			// some pre defined constants for most used punctuation
+			public static readonly Role<VBTokenNode> LPar = new Role<VBTokenNode>("LPar", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> RPar = new Role<VBTokenNode>("RPar", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> LBracket = new Role<VBTokenNode>("LBracket", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> RBracket = new Role<VBTokenNode>("RBracket", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> LBrace = new Role<VBTokenNode>("LBrace", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> RBrace = new Role<VBTokenNode>("RBrace", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> LChevron = new Role<VBTokenNode>("LChevron", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> RChevron = new Role<VBTokenNode>("RChevron", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> Comma = new Role<VBTokenNode>("Comma", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> Dot = new Role<VBTokenNode>("Dot", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> Semicolon = new Role<VBTokenNode>("Semicolon", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> Assign = new Role<VBTokenNode>("Assign", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> Colon = new Role<VBTokenNode>("Colon", VBTokenNode.Null);
+			public static readonly Role<VBTokenNode> StatementTerminator = new Role<VBTokenNode>("StatementTerminator", VBTokenNode.Null);
+			
+			// XML
+			/// <summary>
+			/// Text: &lt;
+			/// </summary>
+			public static readonly Role<VBTokenNode> XmlOpenTag = new Role<VBTokenNode>("XmlOpenTag", VBTokenNode.Null);
+			/// <summary>
+			/// Text: &gt;
+			/// </summary>
+			public static readonly Role<VBTokenNode> XmlCloseTag = new Role<VBTokenNode>("XmlOpenTag", VBTokenNode.Null);
+			
+			public static readonly Role<Comment> Comment = new Role<Comment>("Comment");
+			
+		}
+	}
+	
+	public class Comment
+	{
+		
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstNodeCollection.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstNodeCollection.cs
new file mode 100644
index 000000000..236f27a0b
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/AstNodeCollection.cs
@@ -0,0 +1,209 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+
+using ICSharpCode.NRefactory.PatternMatching;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	/// <summary>
+	/// Represents the children of an AstNode that have a specific role.
+	/// </summary>
+	public class AstNodeCollection<T> : ICollection<T> where T : AstNode
+	{
+		readonly AstNode node;
+		readonly Role<T> role;
+		
+		public AstNodeCollection(AstNode node, Role<T> role)
+		{
+			if (node == null)
+				throw new ArgumentNullException("node");
+			if (role == null)
+				throw new ArgumentNullException("role");
+			this.node = node;
+			this.role = role;
+		}
+		
+		public int Count {
+			get {
+				int count = 0;
+				for (AstNode cur = node.FirstChild; cur != null; cur = cur.NextSibling) {
+					if (cur.Role == role)
+						count++;
+				}
+				return count;
+			}
+		}
+		
+		public void Add(T element)
+		{
+			node.AddChild(element, role);
+		}
+		
+		public void AddRange(IEnumerable<T> nodes)
+		{
+			// Evaluate 'nodes' first, since it might change when we add the new children
+			// Example: collection.AddRange(collection);
+			if (nodes != null) {
+				foreach (T node in nodes.ToList())
+					Add(node);
+			}
+		}
+		
+		public void AddRange(T[] nodes)
+		{
+			// Fast overload for arrays - we don't need to create a copy
+			if (nodes != null) {
+				foreach (T node in nodes)
+					Add(node);
+			}
+		}
+		
+		public void ReplaceWith(IEnumerable<T> nodes)
+		{
+			// Evaluate 'nodes' first, since it might change when we call Clear()
+			// Example: collection.ReplaceWith(collection);
+			if (nodes != null)
+				nodes = nodes.ToList();
+			Clear();
+			foreach (T node in nodes)
+				Add(node);
+		}
+		
+		public void MoveTo(ICollection<T> targetCollection)
+		{
+			foreach (T node in this) {
+				node.Remove();
+				targetCollection.Add(node);
+			}
+		}
+		
+		public bool Contains(T element)
+		{
+			return element != null && element.Parent == node && element.Role == role;
+		}
+		
+		public bool Remove(T element)
+		{
+			if (Contains(element)) {
+				element.Remove();
+				return true;
+			} else {
+				return false;
+			}
+		}
+		
+		public void CopyTo(T[] array, int arrayIndex)
+		{
+			foreach (T item in this)
+				array[arrayIndex++] = item;
+		}
+		
+		public void Clear()
+		{
+			foreach (T item in this)
+				item.Remove();
+		}
+		
+		bool ICollection<T>.IsReadOnly {
+			get { return false; }
+		}
+		
+		public IEnumerator<T> GetEnumerator()
+		{
+			AstNode next;
+			for (AstNode cur = node.FirstChild; cur != null; cur = next) {
+				Debug.Assert(cur.Parent == node);
+				// Remember next before yielding cur.
+				// This allows removing/replacing nodes while iterating through the list.
+				next = cur.NextSibling;
+				if (cur.Role == role)
+					yield return (T)cur;
+			}
+		}
+		
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return GetEnumerator();
+		}
+		
+		#region Equals and GetHashCode implementation
+		public override bool Equals(object obj)
+		{
+			if (obj is AstNodeCollection<T>) {
+				return ((AstNodeCollection<T>)obj) == this;
+			} else {
+				return false;
+			}
+		}
+		
+		public override int GetHashCode()
+		{
+			return node.GetHashCode() ^ role.GetHashCode();
+		}
+		
+		public static bool operator ==(AstNodeCollection<T> left, AstNodeCollection<T> right)
+		{
+			return left.role == right.role && left.node == right.node;
+		}
+		
+		public static bool operator !=(AstNodeCollection<T> left, AstNodeCollection<T> right)
+		{
+			return !(left.role == right.role && left.node == right.node);
+		}
+		#endregion
+		
+		internal bool DoMatch(AstNodeCollection<T> other, Match match)
+		{
+			// TODO : does not compile (ask Daniel)!
+//			Stack<AstNode> patternStack = new Stack<AstNode>();
+//			Stack<Pattern.PossibleMatch> stack = new Stack<Pattern.PossibleMatch>();
+//			patternStack.Push(this.node.FirstChild);
+//			stack.Push(new Pattern.PossibleMatch(other.node.FirstChild, match.CheckPoint()));
+//			while (stack.Count > 0) {
+//				AstNode cur1 = patternStack.Pop();
+//				AstNode cur2 = stack.Peek().NextOther;
+//				match.RestoreCheckPoint(stack.Pop().Checkpoint);
+//				bool success = true;
+//				while (cur1 != null && success) {
+//					while (cur1 != null && cur1.Role != role)
+//						cur1 = cur1.NextSibling;
+//					while (cur2 != null && cur2.Role != role)
+//						cur2 = cur2.NextSibling;
+//					if (cur1 == null)
+//						break;
+//					
+//					Debug.Assert(stack.Count == patternStack.Count);
+//					success = cur1.DoMatchCollection(role, cur2, match, stack);
+//					Debug.Assert(stack.Count >= patternStack.Count);
+//					while (stack.Count > patternStack.Count)
+//						patternStack.Push(cur1.NextSibling);
+//					
+//					cur1 = cur1.NextSibling;
+//					if (cur2 != null)
+//						cur2 = cur2.NextSibling;
+//				}
+//				while (cur2 != null && cur2.Role != role)
+//					cur2 = cur2.NextSibling;
+//				if (success && cur2 == null)
+//					return true;
+//			}
+			return false;
+		}
+		
+		public void InsertAfter(T existingItem, T newItem)
+		{
+			node.InsertChildAfter(existingItem, newItem, role);
+		}
+		
+		public void InsertBefore(T existingItem, T newItem)
+		{
+			node.InsertChildBefore(existingItem, newItem, role);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Enums.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Enums.cs
index f0c6c27b4..d0fc13929 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Enums.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Enums.cs
@@ -10,82 +10,45 @@ namespace ICSharpCode.NRefactory.VB.Ast
 	{
 		None      = 0x0000,
 		
-		// Access
+		// Accessibility
 		Private   = 0x0001,
-		/// <summary>C# 'internal', VB 'Friend'</summary>
-		Internal  = 0x0002,
+		Friend    = 0x0002,
 		Protected = 0x0004,
 		Public    = 0x0008,
 		
 		// Scope
-		Abstract  = 0x0010,  // == 	MustOverride/MustInherit
-		Virtual   = 0x0020,
-		Sealed    = 0x0040,
-		/// <summary>C# 'static', VB 'Shared'</summary>
-		Static    = 0x0080,
-		Override  = 0x0100,
-		/// <summary>For fields: readonly (c# and vb), for properties: get-only (vb)</summary>
-		ReadOnly  = 0x0200,
-		Const	  = 0x0400,
-		/// <summary>C# 'new', VB 'Shadows'</summary>
-		New       = 0x0800,
-		Partial   = 0x1000,
+		MustInherit     = 0x0010,  // Types
+		MustOverride    = 0x0020,  // Members
+		Overridable     = 0x0040,
+		NotInheritable  = 0x0080,  // Types
+		NotOverridable  = 0x0100,  // Members
+		Const           = 0x0200,
+		Shared          = 0x0400,
+		Static          = 0x0800,
+		Override        = 0x1000,
+		ReadOnly        = 0x2000,
+		Shadows         = 0x4000,
+		Partial         = 0x8000,
 		
 		// Special
-		Extern     = 0x2000,
-		Volatile   = 0x4000,
-		Unsafe     = 0x8000,
 		Overloads  = 0x10000, // VB specific
 		WithEvents = 0x20000, // VB specific
 		Default    = 0x40000, // VB specific
-		Fixed      = 0x80000, // C# specific (fixed size arrays in unsafe structs)
 		
-		Dim	       = 0x100000,	// VB.NET SPECIFIC, for fields/local variables only
+		Dim	   = 0x80000,	// VB.NET SPECIFIC, for fields/local variables only
 		
-		/// <summary>Generated code, not part of parsed code</summary>
-		Synthetic  = 0x200000,
 		/// <summary>Only for VB properties.</summary>
-		WriteOnly  = 0x400000, // VB specific
+		WriteOnly  = 0x100000, // VB specific
 		
-		Visibility						= Private | Public | Protected | Internal,
-		Classes							= New | Visibility | Abstract | Sealed | Partial | Static,
-		VBModules						= Visibility,
-		VBStructures					= Visibility | New,
-		VBEnums						    = Visibility | New,
-		VBInterfacs					    = Visibility | New,
-		VBDelegates					    = Visibility | New,
-		VBMethods						= Visibility | New | Static | Virtual | Sealed | Abstract | Override | Overloads,
-		VBExternalMethods				= Visibility | New | Overloads,
-		VBEvents						= Visibility | New | Overloads,
-		VBProperties					= VBMethods | Default | ReadOnly | WriteOnly,
-		VBCustomEvents					= Visibility | New | Overloads,
-		VBOperators						= Public | Static | Overloads | New,
+		ByVal      = 0x200000,
+		ByRef      = 0x400000,
+		ParamArray = 0x800000,
+		Optional   = 0x1000000,
 		
-		
-		// this is not documented in the spec
-		VBInterfaceEvents				= New,
-		VBInterfaceMethods				= New | Overloads,
-		VBInterfaceProperties			= New | Overloads | ReadOnly | WriteOnly | Default,
-		VBInterfaceEnums				= New,
-		
-		Fields                          = New | Visibility | Static   | ReadOnly | Volatile | Fixed,
-		PropertysEventsMethods          = New | Visibility | Static   | Virtual  | Sealed   | Override | Abstract | Extern,
-		Indexers                        = New | Visibility | Virtual  | Sealed   | Override | Abstract | Extern,
-		Operators                       = Public | Static | Extern,
-		Constants                       = New | Visibility,
-		StructsInterfacesEnumsDelegates = New | Visibility | Partial,
-		StaticConstructors              = Extern | Static | Unsafe,
-		Destructors                     = Extern | Unsafe,
-		Constructors                    = Visibility | Extern,
-	}
-	
-	public enum ClassType
-	{
-		Class,
-		Module,
-		Interface,
-		Struct,
-		Enum
+		/// <summary>
+		/// Special value used to match any modifiers during pattern matching.
+		/// </summary>
+		Any = unchecked((int)0x80000000)
 	}
 	
 	public enum ParentType
@@ -104,18 +67,6 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		Ref
 	}
 	
-	[Flags]
-	public enum ParameterModifiers
-	{
-		// Values must be the same as in SharpDevelop's ParameterModifiers
-		None = 0,
-		In  = 1,
-		Out = 2,
-		Ref = 4,
-		Params = 8,
-		Optional = 16
-	}
-	
 	public enum VarianceModifier
 	{
 		Invariant,
@@ -359,20 +310,6 @@ namespace ICSharpCode.NRefactory.VB.Ast
 		Ansi
 	}
 	
-	///<summary>
-	/// Compare type, used in the <c>Option Compare</c>
-	/// pragma (VB only).
-	///</summary>
-	public enum OptionType
-	{
-		None,
-		Explicit,
-		Strict,
-		CompareBinary,
-		CompareText,
-		Infer
-	}
-	
 	/// <summary>
 	/// Specifies the ordering direction of a QueryExpressionOrdering node.
 	/// </summary>
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs
new file mode 100644
index 000000000..d15756e3e
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/Expression.cs
@@ -0,0 +1,33 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public abstract class Expression : AstNode
+	{
+		#region Null
+		public new static readonly Expression Null = new NullExpression ();
+		
+		sealed class NullExpression : Expression
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default (S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		#endregion
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/PrimitiveExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/PrimitiveExpression.cs
new file mode 100644
index 000000000..c01adaf8a
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/PrimitiveExpression.cs
@@ -0,0 +1,75 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using ICSharpCode.NRefactory.VB.PrettyPrinter;
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Represents a literal value.
+	/// </summary>
+	public class PrimitiveExpression : Expression
+	{
+		public static readonly object AnyValue = new object();
+		
+		AstLocation startLocation;
+		public override AstLocation StartLocation {
+			get {
+				return startLocation;
+			}
+		}
+		
+		int length;
+		public override AstLocation EndLocation {
+			get {
+				return new AstLocation(StartLocation.Line, StartLocation.Column + length);
+			}
+		}
+		
+		public object Value { get; private set; }
+		
+		string stringValue;
+		
+		public string StringValue {
+			get { return stringValue; } // TODO ?? VBNetOutputVisitor.ToVBNetString(this); }
+		}
+		
+		public PrimitiveExpression(object value)
+		{
+			this.Value = value;
+		}
+		
+		public PrimitiveExpression(object value, string stringValue)
+		{
+			this.Value = value;
+			this.stringValue = stringValue;
+		}
+		
+		public PrimitiveExpression(object value, AstLocation startLocation, int length)
+		{
+			this.Value = value;
+			this.startLocation = startLocation;
+			this.length = length;
+		}
+		
+		public PrimitiveExpression(object value, string stringValue, AstLocation startLocation, int length)
+		{
+			this.Value = value;
+			this.stringValue = stringValue;
+			this.startLocation = startLocation;
+			this.length = length;
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitPrimitiveExpression(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			PrimitiveExpression o = other as PrimitiveExpression;
+			return o != null && (this.Value == AnyValue || object.Equals(this.Value, o.Value));
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs
new file mode 100644
index 000000000..257b8e744
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/SimpleNameExpression.cs
@@ -0,0 +1,27 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Description of IdentifierExpression.
+	/// </summary>
+	public class SimpleNameExpression : Expression
+	{
+		public Identifier Identifier { get; set; }
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var node = other as SimpleNameExpression;
+			return node != null
+				&& Identifier.DoMatch(node.Identifier, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitSimpleNameExpression(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/XmlIdentifier.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/XmlIdentifier.cs
new file mode 100644
index 000000000..7d3a6ca0b
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/XmlIdentifier.cs
@@ -0,0 +1,72 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Description of XmlIdentifier.
+	/// </summary>
+	public class XmlIdentifier : AstNode
+	{
+		public static readonly new XmlIdentifier Null = new NullXmlIdentifier();
+		
+		class NullXmlIdentifier : XmlIdentifier
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default(S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		
+		public string Name { get; set; }
+		
+		AstLocation startLocation;
+		public override AstLocation StartLocation {
+			get { return startLocation; }
+		}
+		
+		AstLocation endLocation;
+		public override AstLocation EndLocation {
+			get { return endLocation; }
+		}
+		
+		private XmlIdentifier()
+		{
+			this.Name = string.Empty;
+		}
+		
+		public XmlIdentifier(string name, AstLocation startLocation, AstLocation endLocation)
+		{
+			this.Name = name;
+			this.startLocation = startLocation;
+			this.endLocation = endLocation;
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var ident = other as XmlIdentifier;
+			return ident != null
+				&& MatchStringXml(Name, ident.Name)
+				&& ident.startLocation == startLocation
+				&& ident.endLocation == endLocation;
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitXmlIdentifier(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/XmlLiteralString.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/XmlLiteralString.cs
new file mode 100644
index 000000000..3195bcd69
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Expressions/XmlLiteralString.cs
@@ -0,0 +1,69 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class XmlLiteralString : AstNode
+	{
+		public static readonly new XmlLiteralString Null = new XmlLiteralString();
+		
+		class NullXmlLiteralString : XmlLiteralString
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default(S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		
+		public string Value { get; set; }
+		
+		AstLocation startLocation;
+		public override AstLocation StartLocation {
+			get { return startLocation; }
+		}
+		
+		AstLocation endLocation;
+		public override AstLocation EndLocation {
+			get { return endLocation; }
+		}
+		
+		private XmlLiteralString()
+		{
+			this.Value = string.Empty;
+		}
+		
+		public XmlLiteralString(string value, AstLocation startLocation, AstLocation endLocation)
+		{
+			this.Value = value;
+			this.startLocation = startLocation;
+			this.endLocation = endLocation;
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var ident = other as XmlLiteralString;
+			return ident != null
+				&& MatchStringXml(Value, ident.Value)
+				&& ident.startLocation == startLocation
+				&& ident.endLocation == endLocation;
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitXmlLiteralString(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Attribute.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Attribute.cs
new file mode 100644
index 000000000..22261575e
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Attribute.cs
@@ -0,0 +1,93 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class Attribute : AstNode
+	{
+		#region PatternPlaceholder
+		public static implicit operator Attribute(PatternMatching.Pattern pattern)
+		{
+			return pattern != null ? new PatternPlaceholder(pattern) : null;
+		}
+		
+		sealed class PatternPlaceholder : Attribute, PatternMatching.INode
+		{
+			readonly PatternMatching.Pattern child;
+			
+			public PatternPlaceholder(PatternMatching.Pattern child)
+			{
+				this.child = child;
+			}
+			
+			public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+			{
+				return visitor.VisitPatternPlaceholder(this, child, data);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return child.DoMatch(other, match);
+			}
+			
+			bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo)
+			{
+				return child.DoMatchCollection(role, pos, match, backtrackingInfo);
+			}
+		}
+		#endregion
+		
+		public static readonly Role<Attribute> AttributeRole = new Role<Attribute>("Attribute");
+		public static readonly Role<VBTokenNode> TargetRole = new Role<VBTokenNode>("Target", VBTokenNode.Null);
+		
+		public VBTokenNode Target {
+			get { return GetChildByRole(TargetRole); }
+			set { SetChildByRole(TargetRole, value); }
+		}
+		
+		public VBTokenNode ColonToken {
+			get { return GetChildByRole(Roles.StatementTerminator); }
+		}
+		
+		public AstType Type {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		public VBTokenNode LParToken {
+			get { return GetChildByRole(Roles.LPar); }
+		}
+		
+		public AstNodeCollection<Expression> Arguments {
+			get { return GetChildrenByRole(Roles.Argument); }
+		}
+		
+		public VBTokenNode RParToken {
+			get { return GetChildByRole(Roles.RPar); }
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitAttribute(this, data);
+		}
+		
+//		public override string ToString()
+//		{
+//			return string.Format("[Attribute Type={0} Arguments={1}]", Type, GetCollectionString(Arguments));
+//		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var node = other as Attribute;
+			return node != null && node.Target.DoMatch(this.Target, match) && node.Type.DoMatch(this.Type, match) && node.Arguments.DoMatch(this.Arguments, match);
+		}
+	}
+	
+	public enum AttributeTarget
+	{
+		Assembly,
+		Module
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/AttributeBlock.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/AttributeBlock.cs
new file mode 100644
index 000000000..2e06d3917
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/AttributeBlock.cs
@@ -0,0 +1,36 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class AttributeBlock : AstNode
+	{
+		public readonly static Role<AttributeBlock> AttributeBlockRole = new Role<AttributeBlock>("AttributeBlock");
+		public readonly static Role<AttributeBlock> ReturnTypeAttributeBlockRole = new Role<AttributeBlock>("ReturnTypeAttributeBlock");
+		
+		public VBTokenNode LChevron {
+			get { return GetChildByRole(Roles.LChevron); }
+		}
+		
+		public AstNodeCollection<Attribute> Attributes {
+			get { return GetChildrenByRole(Attribute.AttributeRole); }
+		}
+		
+		public VBTokenNode RChevron {
+			get { return GetChildByRole(Roles.RChevron); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var node = other as AttributeBlock;
+			return node != null && Attributes.DoMatch(node.Attributes, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitAttributeBlock(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/AttributedNode.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/AttributedNode.cs
new file mode 100644
index 000000000..37e364ee6
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/AttributedNode.cs
@@ -0,0 +1,67 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public abstract class AttributedNode : AstNode
+	{
+		public AstNodeCollection<AttributeBlock> Attributes {
+			get { return GetChildrenByRole(AttributeBlock.AttributeBlockRole); }
+		}
+		
+		public static readonly Role<VBModifierToken> ModifierRole = new Role<VBModifierToken>("Modifier");
+		
+		public Modifiers Modifiers {
+			get { return GetModifiers(this); }
+			set { SetModifiers(this, value); }
+		}
+		
+		public IEnumerable<VBModifierToken> ModifierTokens {
+			get { return GetChildrenByRole (ModifierRole); }
+		}
+		
+		internal static Modifiers GetModifiers(AstNode node)
+		{
+			Modifiers m = 0;
+			foreach (VBModifierToken t in node.GetChildrenByRole (ModifierRole)) {
+				m |= t.Modifier;
+			}
+			return m;
+		}
+		
+		internal static void SetModifiers(AstNode node, Modifiers newValue)
+		{
+			Modifiers oldValue = GetModifiers(node);
+			AstNode insertionPos = node.GetChildrenByRole(Attribute.AttributeRole).LastOrDefault();
+			foreach (Modifiers m in VBModifierToken.AllModifiers) {
+				if ((m & newValue) != 0) {
+					if ((m & oldValue) == 0) {
+						// Modifier was added
+						var newToken = new VBModifierToken(AstLocation.Empty, m);
+						node.InsertChildAfter(insertionPos, newToken, ModifierRole);
+						insertionPos = newToken;
+					} else {
+						// Modifier already exists
+						insertionPos = node.GetChildrenByRole(ModifierRole).First(t => t.Modifier == m);
+					}
+				} else {
+					if ((m & oldValue) != 0) {
+						// Modifier was removed
+						node.GetChildrenByRole (ModifierRole).First(t => t.Modifier == m).Remove();
+					}
+				}
+			}
+		}
+		
+		protected bool MatchAttributesAndModifiers(AttributedNode o, PatternMatching.Match match)
+		{
+			return (this.Modifiers == Modifiers.Any || this.Modifiers == o.Modifiers) && this.Attributes.DoMatch(o.Attributes, match);
+		}
+	}
+	
+
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/BlockStatement.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/BlockStatement.cs
deleted file mode 100644
index 1a3492c86..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/BlockStatement.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public class BlockStatement : Statement
-	{
-		// Children in VB: LabelStatement, EndStatement, Statement
-		
-		public static new BlockStatement Null {
-			get {
-				return NullBlockStatement.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return visitor.VisitBlockStatement(this, data);
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[BlockStatement: Children={0}]",
-			                     GetCollectionString(base.Children));
-		}
-	}
-	
-	internal sealed class NullBlockStatement : BlockStatement
-	{
-		public static readonly NullBlockStatement Instance = new NullBlockStatement();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return data;
-		}
-		public override object AcceptChildren(IAstVisitor visitor, object data)
-		{
-			return data;
-		}
-		public override void AddChild(INode childNode)
-		{
-			throw new InvalidOperationException();
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[NullBlockStatement]");
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/CompilationUnit.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/CompilationUnit.cs
index 41bc8e647..6dbe78427 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/CompilationUnit.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/CompilationUnit.cs
@@ -2,23 +2,80 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using System.Collections;
+using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.VB.Ast
 {
-	public class CompilationUnit : AbstractNode
+	public class CompilationUnit : AstNode 
 	{
-		// Children in C#: UsingAliasDeclaration, UsingDeclaration, AttributeSection, NamespaceDeclaration
-		// Children in VB: OptionStatements, ImportsStatement, AttributeSection, NamespaceDeclaration
+		public static readonly Role<AstNode> MemberRole = new Role<AstNode>("Member", AstNode.Null);
 		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
+		public CompilationUnit ()
 		{
-			return visitor.VisitCompilationUnit(this, data);
 		}
 		
-		public override string ToString()
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
 		{
-			return String.Format("[CompilationUnit]");
+			CompilationUnit o = other as CompilationUnit;
+			return o != null && GetChildrenByRole(MemberRole).DoMatch(o.GetChildrenByRole(MemberRole), match);
+		}
+		
+		public AstNode GetNodeAt (int line, int column)
+		{
+			return GetNodeAt (new AstLocation (line, column));
+		}
+		
+		public AstNode GetNodeAt (AstLocation location)
+		{
+			AstNode node = this;
+			while (node.FirstChild != null) {
+				var child = node.FirstChild;
+				while (child != null) {
+					if (child.StartLocation <= location && location < child.EndLocation) {
+						node = child;
+						break;
+					}
+					child = child.NextSibling;
+				}
+				// found no better child node - therefore the parent is the right one.
+				if (child == null)
+					break;
+			}
+			return node;
+		}
+		
+		public IEnumerable<AstNode> GetNodesBetween (int startLine, int startColumn, int endLine, int endColumn)
+		{
+			return GetNodesBetween (new AstLocation (startLine, startColumn), new AstLocation (endLine, endColumn));
+		}
+		
+		public IEnumerable<AstNode> GetNodesBetween (AstLocation start, AstLocation end)
+		{
+			AstNode node = this;
+			while (node != null) {
+				AstNode next;
+				if (start <= node.StartLocation && node.EndLocation <= end) {
+					// Remember next before yielding node.
+					// This allows iteration to continue when the caller removes/replaces the node.
+					next = node.NextSibling;
+					yield return node;
+				} else {
+					if (node.EndLocation < start) {
+						next = node.NextSibling; 
+					} else {
+						next = node.FirstChild;
+					}
+				}
+				
+				if (next != null && next.StartLocation > end)
+					yield break;
+				node = next;
+			}
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitCompilationUnit (this, data);
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Expression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Expression.cs
deleted file mode 100644
index 24824ac73..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Expression.cs
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public abstract class Expression : AbstractNode, INullable
-	{
-		public static Expression Null {
-			get {
-				return NullExpression.Instance;
-			}
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		public static Expression CheckNull(Expression expression)
-		{
-			return expression == null ? NullExpression.Instance : expression;
-		}
-		
-		/// <summary>
-		/// Returns the existing expression plus the specified integer value.
-		/// The old <paramref name="expr"/> object is not modified, but might be a subobject on the new expression
-		/// (and thus its parent property is modified).
-		/// </summary>
-		public static Expression AddInteger(Expression expr, int value)
-		{
-			PrimitiveExpression pe = expr as PrimitiveExpression;
-			if (pe != null && pe.Value is int) {
-				int newVal = (int)pe.Value + value;
-				return new PrimitiveExpression(newVal, newVal.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
-			}
-			BinaryOperatorExpression boe = expr as BinaryOperatorExpression;
-			if (boe != null && boe.Op == BinaryOperatorType.Add) {
-				// clone boe:
-				boe = new BinaryOperatorExpression(boe.Left, boe.Op, boe.Right);
-				
-				boe.Right = AddInteger(boe.Right, value);
-				if (boe.Right is PrimitiveExpression && ((PrimitiveExpression)boe.Right).Value is int) {
-					int newVal = (int)((PrimitiveExpression)boe.Right).Value;
-					if (newVal == 0) {
-						return boe.Left;
-					} else if (newVal < 0) {
-						((PrimitiveExpression)boe.Right).Value = -newVal;
-						boe.Op = BinaryOperatorType.Subtract;
-					}
-				}
-				return boe;
-			}
-			if (boe != null && boe.Op == BinaryOperatorType.Subtract) {
-				pe = boe.Right as PrimitiveExpression;
-				if (pe != null && pe.Value is int) {
-					int newVal = (int)pe.Value - value;
-					if (newVal == 0)
-						return boe.Left;
-					
-					// clone boe:
-					boe = new BinaryOperatorExpression(boe.Left, boe.Op, boe.Right);
-					
-					if (newVal < 0) {
-						newVal = -newVal;
-						boe.Op = BinaryOperatorType.Add;
-					}
-					boe.Right = new PrimitiveExpression(newVal, newVal.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
-					return boe;
-				}
-			}
-			BinaryOperatorType opType = BinaryOperatorType.Add;
-			if (value < 0) {
-				value = -value;
-				opType = BinaryOperatorType.Subtract;
-			}
-			return new BinaryOperatorExpression(expr, opType, new PrimitiveExpression(value, value.ToString(System.Globalization.NumberFormatInfo.InvariantInfo)));
-		}
-	}
-	
-	internal sealed class NullExpression : Expression
-	{
-		internal static readonly NullExpression Instance = new NullExpression();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return null;
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[NullExpression]");
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/LocalVariableDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/LocalVariableDeclaration.cs
deleted file mode 100644
index bc5a9f3f2..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/LocalVariableDeclaration.cs
+++ /dev/null
@@ -1,99 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public class LocalVariableDeclaration : Statement
-	{
-		TypeReference             typeReference;
-		Modifiers                  modifier = Modifiers.None;
-		List<VariableDeclaration> variables = new List<VariableDeclaration>();
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = TypeReference.CheckNull(value);
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public Modifiers Modifier {
-			get {
-				return modifier;
-			}
-			set {
-				modifier = value;
-			}
-		}
-		
-		public List<VariableDeclaration> Variables {
-			get {
-				return variables;
-			}
-		}
-		
-		public TypeReference GetTypeForVariable(int variableIndex)
-		{
-			if (!typeReference.IsNull) {
-				return typeReference;
-			}
-			
-			for (int i = variableIndex; i < Variables.Count;++i) {
-				if (!((VariableDeclaration)Variables[i]).TypeReference.IsNull) {
-					return ((VariableDeclaration)Variables[i]).TypeReference;
-				}
-			}
-			return null;
-		}
-		
-		public LocalVariableDeclaration(VariableDeclaration declaration) : this(TypeReference.Null)
-		{
-			Variables.Add(declaration);
-		}
-		
-		public LocalVariableDeclaration(TypeReference typeReference)
-		{
-			this.TypeReference = typeReference;
-		}
-		
-		public LocalVariableDeclaration(TypeReference typeReference, Modifiers modifier)
-		{
-			this.TypeReference = typeReference;
-			this.modifier      = modifier;
-		}
-		
-		public LocalVariableDeclaration(Modifiers modifier)
-		{
-			this.typeReference = TypeReference.Null;
-			this.modifier      = modifier;
-		}
-		
-		public VariableDeclaration GetVariableDeclaration(string variableName)
-		{
-			foreach (VariableDeclaration variableDeclaration in variables) {
-				if (variableDeclaration.Name == variableName) {
-					return variableDeclaration;
-				}
-			}
-			return null;
-		}
-				
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return visitor.VisitLocalVariableDeclaration(this, data);
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[LocalVariableDeclaration: Type={0}, Modifier ={1} Variables={2}]", 
-			                     typeReference, 
-			                     modifier, 
-			                     GetCollectionString(variables));
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs
new file mode 100644
index 000000000..87b4162b4
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/ParameterDeclaration.cs
@@ -0,0 +1,40 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class ParameterDeclaration : AttributedNode
+	{
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public Expression OptionalValue {
+			get { return GetChildByRole(Roles.Expression); }
+			set { SetChildByRole(Roles.Expression, value); }
+		}
+		
+		public AstType ReturnType {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var param = other as ParameterDeclaration;
+			return param != null &&
+				MatchAttributesAndModifiers(param, match) &&
+				Name.DoMatch(param.Name, match) &&
+				OptionalValue.DoMatch(param.OptionalValue, match) &&
+				ReturnType.DoMatch(param.ReturnType, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitParameterDeclaration(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/PrimitiveExpression.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/PrimitiveExpression.cs
deleted file mode 100644
index b7676a663..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/PrimitiveExpression.cs
+++ /dev/null
@@ -1,53 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using ICSharpCode.NRefactory.VB.PrettyPrinter;
-using System;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public class PrimitiveExpression : Expression
-	{
-		string stringValue;
-		
-		public Parser.LiteralFormat LiteralFormat { get; set; }
-		public object Value { get; set; }
-		
-		public string StringValue {
-			get {
-				if (stringValue == null)
-					return VBNetOutputVisitor.ToVBNetString(this);
-				else
-					return stringValue;
-			}
-			set {
-				stringValue = value == null ? String.Empty : value;
-			}
-		}
-		
-		public PrimitiveExpression(object val)
-		{
-			this.Value = val;
-		}
-		
-		public PrimitiveExpression(object val, string stringValue)
-		{
-			this.Value       = val;
-			this.StringValue = stringValue;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return visitor.VisitPrimitiveExpression(this, data);
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[PrimitiveExpression: Value={1}, ValueType={2}, StringValue={0}]",
-			                     this.StringValue,
-			                     this.Value,
-			                     this.Value == null ? "null" : this.Value.GetType().FullName
-			                    );
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Statement.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Statement.cs
deleted file mode 100644
index 8859bbc2f..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/Statement.cs
+++ /dev/null
@@ -1,62 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public abstract class Statement : AbstractNode, INullable
-	{
-		public static Statement Null {
-			get {
-				return NullStatement.Instance;
-			}
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		public static Statement CheckNull(Statement statement)
-		{
-			return statement ?? NullStatement.Instance;
-		}
-	}
-	
-	public abstract class StatementWithEmbeddedStatement : Statement
-	{
-		Statement embeddedStatement;
-		
-		public Statement EmbeddedStatement {
-			get {
-				return embeddedStatement;
-			}
-			set {
-				embeddedStatement = Statement.CheckNull(value);
-				if (value != null)
-					value.Parent = this;
-			}
-		}
-	}
-	
-	internal sealed class NullStatement : Statement
-	{
-		public static readonly NullStatement Instance = new NullStatement();
-		
-		public override bool IsNull {
-			get { return true; }
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return data;
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[NullStatement]");
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs
new file mode 100644
index 000000000..794615fc2
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/General/TypeParameterDeclaration.cs
@@ -0,0 +1,44 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// [In|Out] Name [As Contraints]
+	/// 
+	/// Represents a type parameter.
+	/// </summary>
+	public class TypeParameterDeclaration : AstNode
+	{
+		public static readonly Role<AstType> TypeConstraintRole = TypeDeclaration.InheritsTypeRole;
+		public static readonly Role<VBTokenNode> VarianceRole = new Role<VBTokenNode>("Variance");
+		
+		public VarianceModifier Variance { get; set; }
+		
+		public string Name {
+			get { return GetChildByRole (Roles.Identifier).Name; }
+			set { SetChildByRole(Roles.Identifier, new Identifier(value, AstLocation.Empty)); }
+		}
+		
+		public AstNodeCollection<AstType> Constraints {
+			get { return GetChildrenByRole(TypeConstraintRole); }
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitTypeParameterDeclaration(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			TypeParameterDeclaration o = other as TypeParameterDeclaration;
+			return o != null && this.Variance == o.Variance
+				&& MatchString(this.Name, o.Name)
+				&& this.Constraints.DoMatch(o.Constraints, match);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Generated.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Generated.cs
index 64315b83f..bd973a0d7 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Generated.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Generated.cs
@@ -1,5153 +1,4866 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.1
+//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+//// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+//using System;
+//using System.Collections.Generic;
 //
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace ICSharpCode.NRefactory.VB.Ast {
-	using System;
-	using System.Collections.Generic;
-	
-	
-	public class AddHandlerStatement : Statement {
-		
-		Expression eventExpression;
-		
-		Expression handlerExpression;
-		
-		public Expression EventExpression {
-			get {
-				return eventExpression;
-			}
-			set {
-				eventExpression = value ?? Expression.Null;
-				if (!eventExpression.IsNull) eventExpression.Parent = this;
-			}
-		}
-		
-		public Expression HandlerExpression {
-			get {
-				return handlerExpression;
-			}
-			set {
-				handlerExpression = value ?? Expression.Null;
-				if (!handlerExpression.IsNull) handlerExpression.Parent = this;
-			}
-		}
-		
-		public AddHandlerStatement(Expression eventExpression, Expression handlerExpression) {
-			EventExpression = eventExpression;
-			HandlerExpression = handlerExpression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitAddHandlerStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[AddHandlerStatement EventExpression={0} HandlerExpression={1}]", EventExpression, HandlerExpression);
-		}
-	}
-	
-	public class AddressOfExpression : Expression {
-		
-		Expression expression;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public AddressOfExpression(Expression expression) {
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitAddressOfExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[AddressOfExpression Expression={0}]", Expression);
-		}
-	}
-	
-	public class ArrayCreateExpression : Expression {
-		
-		TypeReference createType;
-		
-		List<Expression> arguments;
-		
-		CollectionInitializerExpression arrayInitializer;
-		
-		public TypeReference CreateType {
-			get {
-				return createType;
-			}
-			set {
-				createType = value ?? TypeReference.Null;
-				if (!createType.IsNull) createType.Parent = this;
-			}
-		}
-		
-		public List<Expression> Arguments {
-			get {
-				return arguments;
-			}
-			set {
-				arguments = value ?? new List<Expression>();
-			}
-		}
-		
-		public CollectionInitializerExpression ArrayInitializer {
-			get {
-				return arrayInitializer;
-			}
-			set {
-				arrayInitializer = value ?? CollectionInitializerExpression.Null;
-				if (!arrayInitializer.IsNull) arrayInitializer.Parent = this;
-			}
-		}
-		
-		public ArrayCreateExpression(TypeReference createType) {
-			CreateType = createType;
-			arguments = new List<Expression>();
-			arrayInitializer = CollectionInitializerExpression.Null;
-		}
-		
-		public ArrayCreateExpression(TypeReference createType, List<Expression> arguments) {
-			CreateType = createType;
-			Arguments = arguments;
-			arrayInitializer = CollectionInitializerExpression.Null;
-		}
-		
-		public ArrayCreateExpression(TypeReference createType, CollectionInitializerExpression arrayInitializer) {
-			CreateType = createType;
-			ArrayInitializer = arrayInitializer;
-			arguments = new List<Expression>();
-		}
-		
-		public bool IsImplicitlyTyped {
-			get {
-				return createType.IsNull || string.IsNullOrEmpty(createType.Type);
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitArrayCreateExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ArrayCreateExpression CreateType={0} Arguments={1} ArrayInitializer={2}]", CreateType, GetCollectionString(Arguments), ArrayInitializer);
-		}
-	}
-	
-	public class AssignmentExpression : Expression {
-		
-		Expression left;
-		
-		AssignmentOperatorType op;
-		
-		Expression right;
-		
-		public Expression Left {
-			get {
-				return left;
-			}
-			set {
-				left = value ?? Expression.Null;
-				if (!left.IsNull) left.Parent = this;
-			}
-		}
-		
-		public AssignmentOperatorType Op {
-			get {
-				return op;
-			}
-			set {
-				op = value;
-			}
-		}
-		
-		public Expression Right {
-			get {
-				return right;
-			}
-			set {
-				right = value ?? Expression.Null;
-				if (!right.IsNull) right.Parent = this;
-			}
-		}
-		
-		public AssignmentExpression(Expression left, AssignmentOperatorType op, Expression right) {
-			Left = left;
-			Op = op;
-			Right = right;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitAssignmentExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[AssignmentExpression Left={0} Op={1} Right={2}]", Left, Op, Right);
-		}
-	}
-	
-	public class Attribute : AbstractNode {
-		
-		string name;
-		
-		List<Expression> positionalArguments;
-		
-		List<NamedArgumentExpression> namedArguments;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public List<Expression> PositionalArguments {
-			get {
-				return positionalArguments;
-			}
-			set {
-				positionalArguments = value ?? new List<Expression>();
-			}
-		}
-		
-		public List<NamedArgumentExpression> NamedArguments {
-			get {
-				return namedArguments;
-			}
-			set {
-				namedArguments = value ?? new List<NamedArgumentExpression>();
-			}
-		}
-		
-		public Attribute() {
-			name = "";
-			positionalArguments = new List<Expression>();
-			namedArguments = new List<NamedArgumentExpression>();
-		}
-		
-		public Attribute(string name, List<Expression> positionalArguments, List<NamedArgumentExpression> namedArguments) {
-			Name = name;
-			PositionalArguments = positionalArguments;
-			NamedArguments = namedArguments;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitAttribute(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[Attribute Name={0} PositionalArguments={1} NamedArguments={2}]", Name, GetCollectionString(PositionalArguments), GetCollectionString(NamedArguments));
-		}
-	}
-	
-	public abstract class AttributedNode : AbstractNode {
-		
-		List<AttributeSection> attributes;
-		
-		Modifiers modifier;
-		
-		public List<AttributeSection> Attributes {
-			get {
-				return attributes;
-			}
-			set {
-				attributes = value ?? new List<AttributeSection>();
-			}
-		}
-		
-		public Modifiers Modifier {
-			get {
-				return modifier;
-			}
-			set {
-				modifier = value;
-			}
-		}
-		
-		protected AttributedNode() {
-			attributes = new List<AttributeSection>();
-		}
-		
-		protected AttributedNode(List<AttributeSection> attributes) {
-			Attributes = attributes;
-		}
-		
-		protected AttributedNode(Modifiers modifier, List<AttributeSection> attributes) {
-			Modifier = modifier;
-			Attributes = attributes;
-		}
-	}
-	
-	public class AttributeSection : AbstractNode {
-		
-		string attributeTarget;
-		
-		List<ICSharpCode.NRefactory.VB.Ast.Attribute> attributes;
-		
-		public string AttributeTarget {
-			get {
-				return attributeTarget;
-			}
-			set {
-				attributeTarget = value ?? "";
-			}
-		}
-		
-		public List<ICSharpCode.NRefactory.VB.Ast.Attribute> Attributes {
-			get {
-				return attributes;
-			}
-			set {
-				attributes = value ?? new List<Attribute>();
-			}
-		}
-		
-		public AttributeSection() {
-			attributeTarget = "";
-			attributes = new List<Attribute>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitAttributeSection(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[AttributeSection AttributeTarget={0} Attributes={1}]", AttributeTarget, GetCollectionString(Attributes));
-		}
-	}
-	
-	public class BaseReferenceExpression : Expression {
-		
-		public BaseReferenceExpression() {
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitBaseReferenceExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return "[BaseReferenceExpression]";
-		}
-	}
-	
-	public class BinaryOperatorExpression : Expression {
-		
-		Expression left;
-		
-		BinaryOperatorType op;
-		
-		Expression right;
-		
-		public Expression Left {
-			get {
-				return left;
-			}
-			set {
-				left = value ?? Expression.Null;
-				if (!left.IsNull) left.Parent = this;
-			}
-		}
-		
-		public BinaryOperatorType Op {
-			get {
-				return op;
-			}
-			set {
-				op = value;
-			}
-		}
-		
-		public Expression Right {
-			get {
-				return right;
-			}
-			set {
-				right = value ?? Expression.Null;
-				if (!right.IsNull) right.Parent = this;
-			}
-		}
-		
-		public BinaryOperatorExpression() {
-			left = Expression.Null;
-			right = Expression.Null;
-		}
-		
-		public BinaryOperatorExpression(Expression left, BinaryOperatorType op, Expression right) {
-			Left = left;
-			Op = op;
-			Right = right;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitBinaryOperatorExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[BinaryOperatorExpression Left={0} Op={1} Right={2}]", Left, Op, Right);
-		}
-	}
-	
-	public class CaseLabel : AbstractNode {
-		
-		Expression label;
-		
-		BinaryOperatorType binaryOperatorType;
-		
-		Expression toExpression;
-		
-		public Expression Label {
-			get {
-				return label;
-			}
-			set {
-				label = value ?? Expression.Null;
-				if (!label.IsNull) label.Parent = this;
-			}
-		}
-		
-		public BinaryOperatorType BinaryOperatorType {
-			get {
-				return binaryOperatorType;
-			}
-			set {
-				binaryOperatorType = value;
-			}
-		}
-		
-		public Expression ToExpression {
-			get {
-				return toExpression;
-			}
-			set {
-				toExpression = value ?? Expression.Null;
-				if (!toExpression.IsNull) toExpression.Parent = this;
-			}
-		}
-		
-		public CaseLabel() {
-			label = Expression.Null;
-			toExpression = Expression.Null;
-		}
-		
-		public CaseLabel(Expression label) {
-			Label = label;
-			toExpression = Expression.Null;
-		}
-		
-		public CaseLabel(Expression label, Expression toExpression) {
-			Label = label;
-			ToExpression = toExpression;
-		}
-		
-		public CaseLabel(BinaryOperatorType binaryOperatorType, Expression label) {
-			BinaryOperatorType = binaryOperatorType;
-			Label = label;
-			toExpression = Expression.Null;
-		}
-		
-		public bool IsDefault {
-			get {
-				return label.IsNull;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitCaseLabel(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[CaseLabel Label={0} BinaryOperatorType={1} ToExpression={2}]", Label, BinaryOperatorType, ToExpression);
-		}
-	}
-	
-	public class CastExpression : Expression {
-		
-		TypeReference castTo;
-		
-		Expression expression;
-		
-		CastType castType;
-		
-		public TypeReference CastTo {
-			get {
-				return castTo;
-			}
-			set {
-				castTo = value ?? TypeReference.Null;
-				if (!castTo.IsNull) castTo.Parent = this;
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public CastType CastType {
-			get {
-				return castType;
-			}
-			set {
-				castType = value;
-			}
-		}
-		
-		public CastExpression(TypeReference castTo) {
-			CastTo = castTo;
-			expression = Expression.Null;
-		}
-		
-		public CastExpression(TypeReference castTo, Expression expression, CastType castType) {
-			CastTo = castTo;
-			Expression = expression;
-			CastType = castType;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitCastExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[CastExpression CastTo={0} Expression={1} CastType={2}]", CastTo, Expression, CastType);
-		}
-	}
-	
-	public class CatchClause : AbstractNode {
-		
-		TypeReference typeReference;
-		
-		string variableName;
-		
-		Statement statementBlock;
-		
-		Expression condition;
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public string VariableName {
-			get {
-				return variableName;
-			}
-			set {
-				variableName = value ?? "";
-			}
-		}
-		
-		public Statement StatementBlock {
-			get {
-				return statementBlock;
-			}
-			set {
-				statementBlock = value ?? Statement.Null;
-				if (!statementBlock.IsNull) statementBlock.Parent = this;
-			}
-		}
-		
-		public Expression Condition {
-			get {
-				return condition;
-			}
-			set {
-				condition = value ?? Expression.Null;
-				if (!condition.IsNull) condition.Parent = this;
-			}
-		}
-		
-		public CatchClause(TypeReference typeReference, string variableName, Statement statementBlock) {
-			TypeReference = typeReference;
-			VariableName = variableName;
-			StatementBlock = statementBlock;
-			condition = Expression.Null;
-		}
-		
-		public CatchClause(TypeReference typeReference, string variableName, Statement statementBlock, Expression condition) {
-			TypeReference = typeReference;
-			VariableName = variableName;
-			StatementBlock = statementBlock;
-			Condition = condition;
-		}
-		
-		public CatchClause(Statement statementBlock) {
-			StatementBlock = statementBlock;
-			typeReference = TypeReference.Null;
-			variableName = "";
-			condition = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitCatchClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[CatchClause TypeReference={0} VariableName={1} StatementBlock={2} Condition={3}]" +
-					"", TypeReference, VariableName, StatementBlock, Condition);
-		}
-	}
-	
-	public class ClassReferenceExpression : Expression {
-		
-		public ClassReferenceExpression() {
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitClassReferenceExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return "[ClassReferenceExpression]";
-		}
-	}
-	
-	public class CollectionInitializerExpression : Expression {
-		
-		List<Expression> createExpressions;
-		
-		public List<Expression> CreateExpressions {
-			get {
-				return createExpressions;
-			}
-			set {
-				createExpressions = value ?? new List<Expression>();
-			}
-		}
-		
-		public CollectionInitializerExpression() {
-			createExpressions = new List<Expression>();
-		}
-		
-		public CollectionInitializerExpression(List<Expression> createExpressions) {
-			CreateExpressions = createExpressions;
-		}
-		
-		public new static CollectionInitializerExpression Null {
-			get {
-				return NullCollectionInitializerExpression.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitCollectionInitializerExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[CollectionInitializerExpression CreateExpressions={0}]", GetCollectionString(CreateExpressions));
-		}
-	}
-	
-	internal sealed class NullCollectionInitializerExpression : CollectionInitializerExpression {
-		
-		internal static NullCollectionInitializerExpression Instance = new NullCollectionInitializerExpression();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullCollectionInitializerExpression]";
-		}
-	}
-	
-	public class CollectionRangeVariable : AbstractNode, INullable {
-		
-		string identifier;
-		
-		Expression expression;
-		
-		TypeReference type;
-		
-		public string Identifier {
-			get {
-				return identifier;
-			}
-			set {
-				identifier = value ?? "";
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public TypeReference Type {
-			get {
-				return type;
-			}
-			set {
-				type = value ?? TypeReference.Null;
-				if (!type.IsNull) type.Parent = this;
-			}
-		}
-		
-		public CollectionRangeVariable() {
-			identifier = "";
-			expression = Expression.Null;
-			type = TypeReference.Null;
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		public static CollectionRangeVariable Null {
-			get {
-				return NullCollectionRangeVariable.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitCollectionRangeVariable(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[CollectionRangeVariable Identifier={0} Expression={1} Type={2}]", Identifier, Expression, Type);
-		}
-	}
-	
-	internal sealed class NullCollectionRangeVariable : CollectionRangeVariable {
-		
-		internal static NullCollectionRangeVariable Instance = new NullCollectionRangeVariable();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullCollectionRangeVariable]";
-		}
-	}
-	
-	public class ConditionalExpression : Expression {
-		
-		Expression condition;
-		
-		Expression trueExpression;
-		
-		Expression falseExpression;
-		
-		public Expression Condition {
-			get {
-				return condition;
-			}
-			set {
-				condition = value ?? Expression.Null;
-				if (!condition.IsNull) condition.Parent = this;
-			}
-		}
-		
-		public Expression TrueExpression {
-			get {
-				return trueExpression;
-			}
-			set {
-				trueExpression = value ?? Expression.Null;
-				if (!trueExpression.IsNull) trueExpression.Parent = this;
-			}
-		}
-		
-		public Expression FalseExpression {
-			get {
-				return falseExpression;
-			}
-			set {
-				falseExpression = value ?? Expression.Null;
-				if (!falseExpression.IsNull) falseExpression.Parent = this;
-			}
-		}
-		
-		public ConditionalExpression() {
-			condition = Expression.Null;
-			trueExpression = Expression.Null;
-			falseExpression = Expression.Null;
-		}
-		
-		public ConditionalExpression(Expression condition, Expression trueExpression, Expression falseExpression) {
-			Condition = condition;
-			TrueExpression = trueExpression;
-			FalseExpression = falseExpression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitConditionalExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ConditionalExpression Condition={0} TrueExpression={1} FalseExpression={2}]", Condition, TrueExpression, FalseExpression);
-		}
-	}
-	
-	public class ConstructorDeclaration : ParametrizedNode {
-		
-		ConstructorInitializer constructorInitializer;
-		
-		BlockStatement body;
-		
-		public ConstructorInitializer ConstructorInitializer {
-			get {
-				return constructorInitializer;
-			}
-			set {
-				constructorInitializer = value ?? ConstructorInitializer.Null;
-				if (!constructorInitializer.IsNull) constructorInitializer.Parent = this;
-			}
-		}
-		
-		public BlockStatement Body {
-			get {
-				return body;
-			}
-			set {
-				body = value ?? BlockStatement.Null;
-				if (!body.IsNull) body.Parent = this;
-			}
-		}
-		
-		public ConstructorDeclaration(string name, Modifiers modifier, List<ParameterDeclarationExpression> parameters, List<AttributeSection> attributes) {
-			Name = name;
-			Modifier = modifier;
-			Parameters = parameters;
-			Attributes = attributes;
-			constructorInitializer = ConstructorInitializer.Null;
-			body = BlockStatement.Null;
-		}
-		
-		public ConstructorDeclaration(string name, Modifiers modifier, List<ParameterDeclarationExpression> parameters, ConstructorInitializer constructorInitializer, List<AttributeSection> attributes) {
-			Name = name;
-			Modifier = modifier;
-			Parameters = parameters;
-			ConstructorInitializer = constructorInitializer;
-			Attributes = attributes;
-			body = BlockStatement.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitConstructorDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ConstructorDeclaration ConstructorInitializer={0} Body={1} Name={2} Parameters={" +
-					"3} Attributes={4} Modifier={5}]", ConstructorInitializer, Body, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class ConstructorInitializer : AbstractNode, INullable {
-		
-		ConstructorInitializerType constructorInitializerType;
-		
-		List<Expression> arguments;
-		
-		public ConstructorInitializerType ConstructorInitializerType {
-			get {
-				return constructorInitializerType;
-			}
-			set {
-				constructorInitializerType = value;
-			}
-		}
-		
-		public List<Expression> Arguments {
-			get {
-				return arguments;
-			}
-			set {
-				arguments = value ?? new List<Expression>();
-			}
-		}
-		
-		public ConstructorInitializer() {
-			arguments = new List<Expression>();
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		public static ConstructorInitializer Null {
-			get {
-				return NullConstructorInitializer.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitConstructorInitializer(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ConstructorInitializer ConstructorInitializerType={0} Arguments={1}]", ConstructorInitializerType, GetCollectionString(Arguments));
-		}
-	}
-	
-	internal sealed class NullConstructorInitializer : ConstructorInitializer {
-		
-		internal static NullConstructorInitializer Instance = new NullConstructorInitializer();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullConstructorInitializer]";
-		}
-	}
-	
-	public class ContinueStatement : Statement {
-		
-		ContinueType continueType;
-		
-		public ContinueType ContinueType {
-			get {
-				return continueType;
-			}
-			set {
-				continueType = value;
-			}
-		}
-		
-		public ContinueStatement() {
-		}
-		
-		public ContinueStatement(ContinueType continueType) {
-			ContinueType = continueType;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitContinueStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ContinueStatement ContinueType={0}]", ContinueType);
-		}
-	}
-	
-	public class DeclareDeclaration : ParametrizedNode {
-		
-		string alias;
-		
-		string library;
-		
-		CharsetModifier charset;
-		
-		TypeReference typeReference;
-		
-		public string Alias {
-			get {
-				return alias;
-			}
-			set {
-				alias = value ?? "";
-			}
-		}
-		
-		public string Library {
-			get {
-				return library;
-			}
-			set {
-				library = value ?? "";
-			}
-		}
-		
-		public CharsetModifier Charset {
-			get {
-				return charset;
-			}
-			set {
-				charset = value;
-			}
-		}
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public DeclareDeclaration(string name, Modifiers modifier, TypeReference typeReference, List<ParameterDeclarationExpression> parameters, List<AttributeSection> attributes, string library, string alias, CharsetModifier charset) {
-			Name = name;
-			Modifier = modifier;
-			TypeReference = typeReference;
-			Parameters = parameters;
-			Attributes = attributes;
-			Library = library;
-			Alias = alias;
-			Charset = charset;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitDeclareDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[DeclareDeclaration Alias={0} Library={1} Charset={2} TypeReference={3} Name={4} " +
-					"Parameters={5} Attributes={6} Modifier={7}]", Alias, Library, Charset, TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class DefaultValueExpression : Expression {
-		
-		TypeReference typeReference;
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public DefaultValueExpression(TypeReference typeReference) {
-			TypeReference = typeReference;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitDefaultValueExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[DefaultValueExpression TypeReference={0}]", TypeReference);
-		}
-	}
-	
-	public class DelegateDeclaration : AttributedNode {
-		
-		string name;
-		
-		TypeReference returnType;
-		
-		List<ParameterDeclarationExpression> parameters;
-		
-		List<TemplateDefinition> templates;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = string.IsNullOrEmpty(value) ? "?" : value;
-			}
-		}
-		
-		public TypeReference ReturnType {
-			get {
-				return returnType;
-			}
-			set {
-				returnType = value ?? TypeReference.Null;
-				if (!returnType.IsNull) returnType.Parent = this;
-			}
-		}
-		
-		public List<ParameterDeclarationExpression> Parameters {
-			get {
-				return parameters;
-			}
-			set {
-				parameters = value ?? new List<ParameterDeclarationExpression>();
-			}
-		}
-		
-		public List<TemplateDefinition> Templates {
-			get {
-				return templates;
-			}
-			set {
-				templates = value ?? new List<TemplateDefinition>();
-			}
-		}
-		
-		public DelegateDeclaration(Modifiers modifier, List<AttributeSection> attributes) {
-			Modifier = modifier;
-			Attributes = attributes;
-			name = "?";
-			returnType = TypeReference.Null;
-			parameters = new List<ParameterDeclarationExpression>();
-			templates = new List<TemplateDefinition>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitDelegateDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[DelegateDeclaration Name={0} ReturnType={1} Parameters={2} Templates={3} Attribu" +
-					"tes={4} Modifier={5}]", Name, ReturnType, GetCollectionString(Parameters), GetCollectionString(Templates), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class DirectionExpression : Expression {
-		
-		FieldDirection fieldDirection;
-		
-		Expression expression;
-		
-		public FieldDirection FieldDirection {
-			get {
-				return fieldDirection;
-			}
-			set {
-				fieldDirection = value;
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public DirectionExpression(FieldDirection fieldDirection, Expression expression) {
-			FieldDirection = fieldDirection;
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitDirectionExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[DirectionExpression FieldDirection={0} Expression={1}]", FieldDirection, Expression);
-		}
-	}
-	
-	public class DoLoopStatement : StatementWithEmbeddedStatement {
-		
-		Expression condition;
-		
-		ConditionType conditionType;
-		
-		ConditionPosition conditionPosition;
-		
-		public Expression Condition {
-			get {
-				return condition;
-			}
-			set {
-				condition = value ?? Expression.Null;
-				if (!condition.IsNull) condition.Parent = this;
-			}
-		}
-		
-		public ConditionType ConditionType {
-			get {
-				return conditionType;
-			}
-			set {
-				conditionType = value;
-			}
-		}
-		
-		public ConditionPosition ConditionPosition {
-			get {
-				return conditionPosition;
-			}
-			set {
-				conditionPosition = value;
-			}
-		}
-		
-		public DoLoopStatement(Expression condition, Statement embeddedStatement, ConditionType conditionType, ConditionPosition conditionPosition) {
-			Condition = condition;
-			EmbeddedStatement = embeddedStatement;
-			ConditionType = conditionType;
-			ConditionPosition = conditionPosition;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitDoLoopStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[DoLoopStatement Condition={0} ConditionType={1} ConditionPosition={2} EmbeddedSt" +
-					"atement={3}]", Condition, ConditionType, ConditionPosition, EmbeddedStatement);
-		}
-	}
-	
-	public class ElseIfSection : StatementWithEmbeddedStatement {
-		
-		Expression condition;
-		
-		public Expression Condition {
-			get {
-				return condition;
-			}
-			set {
-				condition = value ?? Expression.Null;
-				if (!condition.IsNull) condition.Parent = this;
-			}
-		}
-		
-		public ElseIfSection(Expression condition, Statement embeddedStatement) {
-			Condition = condition;
-			EmbeddedStatement = embeddedStatement;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitElseIfSection(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ElseIfSection Condition={0} EmbeddedStatement={1}]", Condition, EmbeddedStatement);
-		}
-	}
-	
-	public class EndStatement : Statement {
-		
-		public EndStatement() {
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitEndStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return "[EndStatement]";
-		}
-	}
-	
-	public class EraseStatement : Statement {
-		
-		List<Expression> expressions;
-		
-		public List<Expression> Expressions {
-			get {
-				return expressions;
-			}
-			set {
-				expressions = value ?? new List<Expression>();
-			}
-		}
-		
-		public EraseStatement() {
-			expressions = new List<Expression>();
-		}
-		
-		public EraseStatement(List<Expression> expressions) {
-			Expressions = expressions;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitEraseStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[EraseStatement Expressions={0}]", GetCollectionString(Expressions));
-		}
-	}
-	
-	public class ErrorStatement : Statement {
-		
-		Expression expression;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public ErrorStatement(Expression expression) {
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitErrorStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ErrorStatement Expression={0}]", Expression);
-		}
-	}
-	
-	public class EventAddRegion : EventAddRemoveRegion {
-		
-		public EventAddRegion(List<AttributeSection> attributes) : 
-				base(attributes) {
-		}
-		
-		public static EventAddRegion Null {
-			get {
-				return NullEventAddRegion.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitEventAddRegion(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[EventAddRegion Block={0} Parameters={1} Attributes={2} Modifier={3}]", Block, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	internal sealed class NullEventAddRegion : EventAddRegion {
-		
-		private NullEventAddRegion() : 
-				base(null) {
-		}
-		
-		internal static NullEventAddRegion Instance = new NullEventAddRegion();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullEventAddRegion]";
-		}
-	}
-	
-	public abstract class EventAddRemoveRegion : AttributedNode, INullable {
-		
-		BlockStatement block;
-		
-		List<ParameterDeclarationExpression> parameters;
-		
-		public BlockStatement Block {
-			get {
-				return block;
-			}
-			set {
-				block = value ?? BlockStatement.Null;
-				if (!block.IsNull) block.Parent = this;
-			}
-		}
-		
-		public List<ParameterDeclarationExpression> Parameters {
-			get {
-				return parameters;
-			}
-			set {
-				parameters = value ?? new List<ParameterDeclarationExpression>();
-			}
-		}
-		
-		protected EventAddRemoveRegion(List<AttributeSection> attributes) {
-			Attributes = attributes;
-			block = BlockStatement.Null;
-			parameters = new List<ParameterDeclarationExpression>();
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-	}
-	
-	public class EventDeclaration : MemberNode {
-		
-		EventAddRegion addRegion;
-		
-		EventRemoveRegion removeRegion;
-		
-		EventRaiseRegion raiseRegion;
-		
-		Location bodyStart;
-		
-		Location bodyEnd;
-		
-		Expression initializer;
-		
-		public EventAddRegion AddRegion {
-			get {
-				return addRegion;
-			}
-			set {
-				addRegion = value ?? EventAddRegion.Null;
-				if (!addRegion.IsNull) addRegion.Parent = this;
-			}
-		}
-		
-		public EventRemoveRegion RemoveRegion {
-			get {
-				return removeRegion;
-			}
-			set {
-				removeRegion = value ?? EventRemoveRegion.Null;
-				if (!removeRegion.IsNull) removeRegion.Parent = this;
-			}
-		}
-		
-		public EventRaiseRegion RaiseRegion {
-			get {
-				return raiseRegion;
-			}
-			set {
-				raiseRegion = value ?? EventRaiseRegion.Null;
-				if (!raiseRegion.IsNull) raiseRegion.Parent = this;
-			}
-		}
-		
-		public Location BodyStart {
-			get {
-				return bodyStart;
-			}
-			set {
-				bodyStart = value;
-			}
-		}
-		
-		public Location BodyEnd {
-			get {
-				return bodyEnd;
-			}
-			set {
-				bodyEnd = value;
-			}
-		}
-		
-		public Expression Initializer {
-			get {
-				return initializer;
-			}
-			set {
-				initializer = value ?? Expression.Null;
-				if (!initializer.IsNull) initializer.Parent = this;
-			}
-		}
-		
-		public EventDeclaration() {
-			addRegion = EventAddRegion.Null;
-			removeRegion = EventRemoveRegion.Null;
-			raiseRegion = EventRaiseRegion.Null;
-			bodyStart = Location.Empty;
-			bodyEnd = Location.Empty;
-			initializer = Expression.Null;
-		}
-		
-		public bool HasAddRegion {
-			get {
-				return !addRegion.IsNull;
-			}
-		}
-		
-		public bool HasRemoveRegion {
-			get {
-				return !removeRegion.IsNull;
-			}
-		}
-		
-		public bool HasRaiseRegion {
-			get {
-				return !raiseRegion.IsNull;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitEventDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[EventDeclaration AddRegion={0} RemoveRegion={1} RaiseRegion={2} BodyStart={3} Bo" +
-					"dyEnd={4} Initializer={5} InterfaceImplementations={6} TypeReference={7} Name={8" +
-					"} Parameters={9} Attributes={10} Modifier={11}]", AddRegion, RemoveRegion, RaiseRegion, BodyStart, BodyEnd, Initializer, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class EventRaiseRegion : EventAddRemoveRegion {
-		
-		public EventRaiseRegion(List<AttributeSection> attributes) : 
-				base(attributes) {
-		}
-		
-		public static EventRaiseRegion Null {
-			get {
-				return NullEventRaiseRegion.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitEventRaiseRegion(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[EventRaiseRegion Block={0} Parameters={1} Attributes={2} Modifier={3}]", Block, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	internal sealed class NullEventRaiseRegion : EventRaiseRegion {
-		
-		private NullEventRaiseRegion() : 
-				base(null) {
-		}
-		
-		internal static NullEventRaiseRegion Instance = new NullEventRaiseRegion();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullEventRaiseRegion]";
-		}
-	}
-	
-	public class EventRemoveRegion : EventAddRemoveRegion {
-		
-		public EventRemoveRegion(List<AttributeSection> attributes) : 
-				base(attributes) {
-		}
-		
-		public static EventRemoveRegion Null {
-			get {
-				return NullEventRemoveRegion.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitEventRemoveRegion(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[EventRemoveRegion Block={0} Parameters={1} Attributes={2} Modifier={3}]", Block, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	internal sealed class NullEventRemoveRegion : EventRemoveRegion {
-		
-		private NullEventRemoveRegion() : 
-				base(null) {
-		}
-		
-		internal static NullEventRemoveRegion Instance = new NullEventRemoveRegion();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullEventRemoveRegion]";
-		}
-	}
-	
-	public class ExitStatement : Statement {
-		
-		ExitType exitType;
-		
-		public ExitType ExitType {
-			get {
-				return exitType;
-			}
-			set {
-				exitType = value;
-			}
-		}
-		
-		public ExitStatement(ExitType exitType) {
-			ExitType = exitType;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitExitStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ExitStatement ExitType={0}]", ExitType);
-		}
-	}
-	
-	public class ExpressionRangeVariable : AbstractNode, INullable {
-		
-		string identifier;
-		
-		Expression expression;
-		
-		TypeReference type;
-		
-		public string Identifier {
-			get {
-				return identifier;
-			}
-			set {
-				identifier = value ?? "";
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public TypeReference Type {
-			get {
-				return type;
-			}
-			set {
-				type = value ?? TypeReference.Null;
-				if (!type.IsNull) type.Parent = this;
-			}
-		}
-		
-		public ExpressionRangeVariable() {
-			identifier = "";
-			expression = Expression.Null;
-			type = TypeReference.Null;
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		public static ExpressionRangeVariable Null {
-			get {
-				return NullExpressionRangeVariable.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitExpressionRangeVariable(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ExpressionRangeVariable Identifier={0} Expression={1} Type={2}]", Identifier, Expression, Type);
-		}
-	}
-	
-	internal sealed class NullExpressionRangeVariable : ExpressionRangeVariable {
-		
-		internal static NullExpressionRangeVariable Instance = new NullExpressionRangeVariable();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullExpressionRangeVariable]";
-		}
-	}
-	
-	public class ExpressionStatement : Statement {
-		
-		Expression expression;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public ExpressionStatement(Expression expression) {
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitExpressionStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ExpressionStatement Expression={0}]", Expression);
-		}
-	}
-	
-	public class ExternAliasDirective : AbstractNode {
-		
-		string name;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public ExternAliasDirective() {
-			name = "";
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitExternAliasDirective(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ExternAliasDirective Name={0}]", Name);
-		}
-	}
-	
-	public class FieldDeclaration : AttributedNode {
-		
-		TypeReference typeReference;
-		
-		List<VariableDeclaration> fields;
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public List<VariableDeclaration> Fields {
-			get {
-				return fields;
-			}
-			set {
-				fields = value ?? new List<VariableDeclaration>();
-			}
-		}
-		
-		public FieldDeclaration(List<AttributeSection> attributes) {
-			Attributes = attributes;
-			typeReference = TypeReference.Null;
-			fields = new List<VariableDeclaration>();
-		}
-		
-		public FieldDeclaration(List<AttributeSection> attributes, TypeReference typeReference, Modifiers modifier) {
-			Attributes = attributes;
-			TypeReference = typeReference;
-			Modifier = modifier;
-			fields = new List<VariableDeclaration>();
-		}
-		
-
-		public TypeReference GetTypeForField(int fieldIndex)
-		{
-			if (!typeReference.IsNull) {
-				return typeReference;
-			}
-			return ((VariableDeclaration)Fields[fieldIndex]).TypeReference;
-		}
-		
-
-		public VariableDeclaration GetVariableDeclaration(string variableName)
-		{
-			foreach (VariableDeclaration variableDeclaration in Fields) {
-				if (variableDeclaration.Name == variableName) {
-					return variableDeclaration;
-				}
-			}
-			return null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitFieldDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[FieldDeclaration TypeReference={0} Fields={1} Attributes={2} Modifier={3}]", TypeReference, GetCollectionString(Fields), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class ForeachStatement : StatementWithEmbeddedStatement {
-		
-		TypeReference typeReference;
-		
-		string variableName;
-		
-		Expression expression;
-		
-		Expression nextExpression;
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public string VariableName {
-			get {
-				return variableName;
-			}
-			set {
-				variableName = value ?? "";
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public Expression NextExpression {
-			get {
-				return nextExpression;
-			}
-			set {
-				nextExpression = value ?? Expression.Null;
-				if (!nextExpression.IsNull) nextExpression.Parent = this;
-			}
-		}
-		
-		public ForeachStatement(TypeReference typeReference, string variableName, Expression expression, Statement embeddedStatement) {
-			TypeReference = typeReference;
-			VariableName = variableName;
-			Expression = expression;
-			EmbeddedStatement = embeddedStatement;
-			nextExpression = Expression.Null;
-		}
-		
-		public ForeachStatement(TypeReference typeReference, string variableName, Expression expression, Statement embeddedStatement, Expression nextExpression) {
-			TypeReference = typeReference;
-			VariableName = variableName;
-			Expression = expression;
-			EmbeddedStatement = embeddedStatement;
-			NextExpression = nextExpression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitForeachStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ForeachStatement TypeReference={0} VariableName={1} Expression={2} NextExpressio" +
-					"n={3} EmbeddedStatement={4}]", TypeReference, VariableName, Expression, NextExpression, EmbeddedStatement);
-		}
-	}
-	
-	public class ForNextStatement : StatementWithEmbeddedStatement {
-		
-		Expression start;
-		
-		Expression end;
-		
-		Expression step;
-		
-		List<Expression> nextExpressions;
-		
-		TypeReference typeReference;
-		
-		string variableName;
-		
-		Expression loopVariableExpression;
-		
-		public Expression Start {
-			get {
-				return start;
-			}
-			set {
-				start = value ?? Expression.Null;
-				if (!start.IsNull) start.Parent = this;
-			}
-		}
-		
-		public Expression End {
-			get {
-				return end;
-			}
-			set {
-				end = value ?? Expression.Null;
-				if (!end.IsNull) end.Parent = this;
-			}
-		}
-		
-		public Expression Step {
-			get {
-				return step;
-			}
-			set {
-				step = value ?? Expression.Null;
-				if (!step.IsNull) step.Parent = this;
-			}
-		}
-		
-		public List<Expression> NextExpressions {
-			get {
-				return nextExpressions;
-			}
-			set {
-				nextExpressions = value ?? new List<Expression>();
-			}
-		}
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public string VariableName {
-			get {
-				return variableName;
-			}
-			set {
-				variableName = value ?? "";
-			}
-		}
-		
-		public Expression LoopVariableExpression {
-			get {
-				return loopVariableExpression;
-			}
-			set {
-				loopVariableExpression = value ?? Expression.Null;
-				if (!loopVariableExpression.IsNull) loopVariableExpression.Parent = this;
-			}
-		}
-		
-		public ForNextStatement() {
-			start = Expression.Null;
-			end = Expression.Null;
-			step = Expression.Null;
-			nextExpressions = new List<Expression>();
-			typeReference = TypeReference.Null;
-			variableName = "";
-			loopVariableExpression = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitForNextStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ForNextStatement Start={0} End={1} Step={2} NextExpressions={3} TypeReference={4" +
-					"} VariableName={5} LoopVariableExpression={6} EmbeddedStatement={7}]", Start, End, Step, GetCollectionString(NextExpressions), TypeReference, VariableName, LoopVariableExpression, EmbeddedStatement);
-		}
-	}
-	
-	public class GotoStatement : Statement {
-		
-		string label;
-		
-		public string Label {
-			get {
-				return label;
-			}
-			set {
-				label = value ?? "";
-			}
-		}
-		
-		public GotoStatement(string label) {
-			Label = label;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitGotoStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[GotoStatement Label={0}]", Label);
-		}
-	}
-	
-	public class IdentifierExpression : Expression {
-		
-		string identifier;
-		
-		List<TypeReference> typeArguments;
-		
-		public string Identifier {
-			get {
-				return identifier;
-			}
-			set {
-				identifier = value ?? "";
-			}
-		}
-		
-		public List<TypeReference> TypeArguments {
-			get {
-				return typeArguments;
-			}
-			set {
-				typeArguments = value ?? new List<TypeReference>();
-			}
-		}
-		
-		public IdentifierExpression(string identifier) {
-			Identifier = identifier;
-			typeArguments = new List<TypeReference>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitIdentifierExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[IdentifierExpression Identifier={0} TypeArguments={1}]", Identifier, GetCollectionString(TypeArguments));
-		}
-	}
-	
-	public class IfElseStatement : Statement {
-		
-		Expression condition;
-		
-		List<Statement> trueStatement;
-		
-		List<Statement> falseStatement;
-		
-		List<ElseIfSection> elseIfSections;
-		
-		public Expression Condition {
-			get {
-				return condition;
-			}
-			set {
-				condition = value ?? Expression.Null;
-				if (!condition.IsNull) condition.Parent = this;
-			}
-		}
-		
-		public List<Statement> TrueStatement {
-			get {
-				return trueStatement;
-			}
-			set {
-				trueStatement = value ?? new List<Statement>();
-			}
-		}
-		
-		public List<Statement> FalseStatement {
-			get {
-				return falseStatement;
-			}
-			set {
-				falseStatement = value ?? new List<Statement>();
-			}
-		}
-		
-		public List<ElseIfSection> ElseIfSections {
-			get {
-				return elseIfSections;
-			}
-			set {
-				elseIfSections = value ?? new List<ElseIfSection>();
-			}
-		}
-		
-		public IfElseStatement(Expression condition) {
-			Condition = condition;
-			trueStatement = new List<Statement>();
-			falseStatement = new List<Statement>();
-			elseIfSections = new List<ElseIfSection>();
-		}
-		
-
-			public IfElseStatement(Expression condition, Statement trueStatement)
-				: this(condition) {
-				this.trueStatement.Add(Statement.CheckNull(trueStatement));
-				if (trueStatement != null) trueStatement.Parent = this;
-			}
-		
-		public bool HasElseStatements {
-			get {
-				return falseStatement.Count > 0;
-			}
-		}
-		
-		public bool HasElseIfSections {
-			get {
-				return elseIfSections.Count > 0;
-			}
-		}
-		
-
-			public IfElseStatement(Expression condition, Statement trueStatement, Statement falseStatement)
-				: this(condition) {
-				this.trueStatement.Add(Statement.CheckNull(trueStatement));
-				this.falseStatement.Add(Statement.CheckNull(falseStatement));
-				if (trueStatement != null) trueStatement.Parent = this;
-				if (falseStatement != null) falseStatement.Parent = this;
-			}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitIfElseStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[IfElseStatement Condition={0} TrueStatement={1} FalseStatement={2} ElseIfSection" +
-					"s={3}]", Condition, GetCollectionString(TrueStatement), GetCollectionString(FalseStatement), GetCollectionString(ElseIfSections));
-		}
-	}
-	
-	public class InterfaceImplementation : AbstractNode {
-		
-		TypeReference interfaceType;
-		
-		string memberName;
-		
-		public TypeReference InterfaceType {
-			get {
-				return interfaceType;
-			}
-			set {
-				interfaceType = value ?? TypeReference.Null;
-				if (!interfaceType.IsNull) interfaceType.Parent = this;
-			}
-		}
-		
-		public string MemberName {
-			get {
-				return memberName;
-			}
-			set {
-				memberName = string.IsNullOrEmpty(value) ? "?" : value;
-			}
-		}
-		
-		public InterfaceImplementation(TypeReference interfaceType, string memberName) {
-			InterfaceType = interfaceType;
-			MemberName = memberName;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitInterfaceImplementation(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[InterfaceImplementation InterfaceType={0} MemberName={1}]", InterfaceType, MemberName);
-		}
-	}
-	
-	public class InvocationExpression : Expression {
-		
-		Expression targetObject;
-		
-		List<Expression> arguments;
-		
-		public Expression TargetObject {
-			get {
-				return targetObject;
-			}
-			set {
-				targetObject = value ?? Expression.Null;
-				if (!targetObject.IsNull) targetObject.Parent = this;
-			}
-		}
-		
-		public List<Expression> Arguments {
-			get {
-				return arguments;
-			}
-			set {
-				arguments = value ?? new List<Expression>();
-			}
-		}
-		
-		public InvocationExpression(Expression targetObject) {
-			TargetObject = targetObject;
-			arguments = new List<Expression>();
-		}
-		
-		public InvocationExpression(Expression targetObject, List<Expression> arguments) {
-			TargetObject = targetObject;
-			Arguments = arguments;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitInvocationExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[InvocationExpression TargetObject={0} Arguments={1}]", TargetObject, GetCollectionString(Arguments));
-		}
-	}
-	
-	public class LabelStatement : Statement {
-		
-		string label;
-		
-		public string Label {
-			get {
-				return label;
-			}
-			set {
-				label = value ?? "";
-			}
-		}
-		
-		public LabelStatement(string label) {
-			Label = label;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitLabelStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[LabelStatement Label={0}]", Label);
-		}
-	}
-	
-	public class LambdaExpression : Expression {
-		
-		List<ParameterDeclarationExpression> parameters;
-		
-		Statement statementBody;
-		
-		Expression expressionBody;
-		
-		TypeReference returnType;
-		
-		public List<ParameterDeclarationExpression> Parameters {
-			get {
-				return parameters;
-			}
-			set {
-				parameters = value ?? new List<ParameterDeclarationExpression>();
-			}
-		}
-		
-		public Statement StatementBody {
-			get {
-				return statementBody;
-			}
-			set {
-				statementBody = value ?? Statement.Null;
-				if (!statementBody.IsNull) statementBody.Parent = this;
-			}
-		}
-		
-		public Expression ExpressionBody {
-			get {
-				return expressionBody;
-			}
-			set {
-				expressionBody = value ?? Expression.Null;
-				if (!expressionBody.IsNull) expressionBody.Parent = this;
-			}
-		}
-		
-		public TypeReference ReturnType {
-			get {
-				return returnType;
-			}
-			set {
-				returnType = value ?? TypeReference.Null;
-				if (!returnType.IsNull) returnType.Parent = this;
-			}
-		}
-		
-		public LambdaExpression() {
-			parameters = new List<ParameterDeclarationExpression>();
-			statementBody = Statement.Null;
-			expressionBody = Expression.Null;
-			returnType = TypeReference.Null;
-		}
-		
-public Location ExtendedEndLocation { get; set; }
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitLambdaExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[LambdaExpression Parameters={0} StatementBody={1} ExpressionBody={2} ReturnType=" +
-					"{3}]", GetCollectionString(Parameters), StatementBody, ExpressionBody, ReturnType);
-		}
-	}
-	
-	public class LockStatement : StatementWithEmbeddedStatement {
-		
-		Expression lockExpression;
-		
-		public Expression LockExpression {
-			get {
-				return lockExpression;
-			}
-			set {
-				lockExpression = value ?? Expression.Null;
-				if (!lockExpression.IsNull) lockExpression.Parent = this;
-			}
-		}
-		
-		public LockStatement(Expression lockExpression, Statement embeddedStatement) {
-			LockExpression = lockExpression;
-			EmbeddedStatement = embeddedStatement;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitLockStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[LockStatement LockExpression={0} EmbeddedStatement={1}]", LockExpression, EmbeddedStatement);
-		}
-	}
-	
-	public class MemberInitializerExpression : Expression {
-		
-		string name;
-		
-		bool isKey;
-		
-		Expression expression;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public bool IsKey {
-			get {
-				return isKey;
-			}
-			set {
-				isKey = value;
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public MemberInitializerExpression() {
-			name = "";
-			expression = Expression.Null;
-		}
-		
-		public MemberInitializerExpression(string name, Expression expression) {
-			Name = name;
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitMemberInitializerExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[MemberInitializerExpression Name={0} IsKey={1} Expression={2}]", Name, IsKey, Expression);
-		}
-	}
-	
-	public abstract class MemberNode : ParametrizedNode {
-		
-		List<InterfaceImplementation> interfaceImplementations;
-		
-		TypeReference typeReference;
-		
-		public List<InterfaceImplementation> InterfaceImplementations {
-			get {
-				return interfaceImplementations;
-			}
-			set {
-				interfaceImplementations = value ?? new List<InterfaceImplementation>();
-			}
-		}
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		protected MemberNode() {
-			interfaceImplementations = new List<InterfaceImplementation>();
-			typeReference = TypeReference.Null;
-		}
-		
-		protected MemberNode(Modifiers modifier, List<AttributeSection> attributes, string name, List<ParameterDeclarationExpression> parameters) {
-			Modifier = modifier;
-			Attributes = attributes;
-			Name = name;
-			Parameters = parameters;
-			interfaceImplementations = new List<InterfaceImplementation>();
-			typeReference = TypeReference.Null;
-		}
-	}
-	
-	public class MemberReferenceExpression : Expression {
-		
-		Expression targetObject;
-		
-		string memberName;
-		
-		List<TypeReference> typeArguments;
-		
-		public Expression TargetObject {
-			get {
-				return targetObject;
-			}
-			set {
-				targetObject = value ?? Expression.Null;
-				if (!targetObject.IsNull) targetObject.Parent = this;
-			}
-		}
-		
-		public string MemberName {
-			get {
-				return memberName;
-			}
-			set {
-				memberName = value ?? "";
-			}
-		}
-		
-		public List<TypeReference> TypeArguments {
-			get {
-				return typeArguments;
-			}
-			set {
-				typeArguments = value ?? new List<TypeReference>();
-			}
-		}
-		
-		public MemberReferenceExpression(Expression targetObject, string memberName) {
-			TargetObject = targetObject;
-			MemberName = memberName;
-			typeArguments = new List<TypeReference>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitMemberReferenceExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[MemberReferenceExpression TargetObject={0} MemberName={1} TypeArguments={2}]", TargetObject, MemberName, GetCollectionString(TypeArguments));
-		}
-	}
-	
-	public class MethodDeclaration : MemberNode {
-		
-		BlockStatement body;
-		
-		List<string> handlesClause;
-		
-		List<TemplateDefinition> templates;
-		
-		bool isExtensionMethod;
-		
-		public BlockStatement Body {
-			get {
-				return body;
-			}
-			set {
-				body = value ?? BlockStatement.Null;
-				if (!body.IsNull) body.Parent = this;
-			}
-		}
-		
-		public List<string> HandlesClause {
-			get {
-				return handlesClause;
-			}
-			set {
-				handlesClause = value ?? new List<String>();
-			}
-		}
-		
-		public List<TemplateDefinition> Templates {
-			get {
-				return templates;
-			}
-			set {
-				templates = value ?? new List<TemplateDefinition>();
-			}
-		}
-		
-		public bool IsExtensionMethod {
-			get {
-				return isExtensionMethod;
-			}
-			set {
-				isExtensionMethod = value;
-			}
-		}
-		
-		public MethodDeclaration() {
-			body = BlockStatement.Null;
-			handlesClause = new List<String>();
-			templates = new List<TemplateDefinition>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitMethodDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[MethodDeclaration Body={0} HandlesClause={1} Templates={2} IsExtensionMethod={3}" +
-					" InterfaceImplementations={4} TypeReference={5} Name={6} Parameters={7} Attribut" +
-					"es={8} Modifier={9}]", Body, GetCollectionString(HandlesClause), GetCollectionString(Templates), IsExtensionMethod, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class NamedArgumentExpression : Expression {
-		
-		string name;
-		
-		Expression expression;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public NamedArgumentExpression() {
-			name = "";
-			expression = Expression.Null;
-		}
-		
-		public NamedArgumentExpression(string name, Expression expression) {
-			Name = name;
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitNamedArgumentExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[NamedArgumentExpression Name={0} Expression={1}]", Name, Expression);
-		}
-	}
-	
-	public class NamespaceDeclaration : AbstractNode {
-		
-		string name;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public NamespaceDeclaration(string name) {
-			Name = name;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitNamespaceDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[NamespaceDeclaration Name={0}]", Name);
-		}
-	}
-	
-	public class ObjectCreateExpression : Expression {
-		
-		TypeReference createType;
-		
-		List<Expression> parameters;
-		
-		CollectionInitializerExpression objectInitializer;
-		
-		public TypeReference CreateType {
-			get {
-				return createType;
-			}
-			set {
-				createType = value ?? TypeReference.Null;
-				if (!createType.IsNull) createType.Parent = this;
-			}
-		}
-		
-		public List<Expression> Parameters {
-			get {
-				return parameters;
-			}
-			set {
-				parameters = value ?? new List<Expression>();
-			}
-		}
-		
-		public CollectionInitializerExpression ObjectInitializer {
-			get {
-				return objectInitializer;
-			}
-			set {
-				objectInitializer = value ?? CollectionInitializerExpression.Null;
-				if (!objectInitializer.IsNull) objectInitializer.Parent = this;
-			}
-		}
-		
-		public ObjectCreateExpression(TypeReference createType, List<Expression> parameters) {
-			CreateType = createType;
-			Parameters = parameters;
-			objectInitializer = CollectionInitializerExpression.Null;
-		}
-		
-		public bool IsAnonymousType {
-			get {
-				return createType.IsNull || string.IsNullOrEmpty(createType.Type);
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitObjectCreateExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ObjectCreateExpression CreateType={0} Parameters={1} ObjectInitializer={2}]", CreateType, GetCollectionString(Parameters), ObjectInitializer);
-		}
-	}
-	
-	public class OnErrorStatement : StatementWithEmbeddedStatement {
-		
-		public OnErrorStatement(Statement embeddedStatement) {
-			EmbeddedStatement = embeddedStatement;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitOnErrorStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[OnErrorStatement EmbeddedStatement={0}]", EmbeddedStatement);
-		}
-	}
-	
-	public class OperatorDeclaration : MethodDeclaration {
-		
-		ConversionType conversionType;
-		
-		OverloadableOperatorType overloadableOperator;
-		
-		public ConversionType ConversionType {
-			get {
-				return conversionType;
-			}
-			set {
-				conversionType = value;
-			}
-		}
-		
-		public OverloadableOperatorType OverloadableOperator {
-			get {
-				return overloadableOperator;
-			}
-			set {
-				overloadableOperator = value;
-			}
-		}
-		
-		public OperatorDeclaration() {
-		}
-		
-		public bool IsConversionOperator {
-			get {
-				return conversionType != ConversionType.None;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitOperatorDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[OperatorDeclaration ConversionType={0} OverloadableOperator={1} Body={2} Handles" +
-					"Clause={3} Templates={4} IsExtensionMethod={5} InterfaceImplementations={6} Type" +
-					"Reference={7} Name={8} Parameters={9} Attributes={10} Modifier={11}]", ConversionType, OverloadableOperator, Body, GetCollectionString(HandlesClause), GetCollectionString(Templates), IsExtensionMethod, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class OptionDeclaration : AbstractNode {
-		
-		OptionType optionType;
-		
-		bool optionValue;
-		
-		public OptionType OptionType {
-			get {
-				return optionType;
-			}
-			set {
-				optionType = value;
-			}
-		}
-		
-		public bool OptionValue {
-			get {
-				return optionValue;
-			}
-			set {
-				optionValue = value;
-			}
-		}
-		
-		public OptionDeclaration(OptionType optionType, bool optionValue) {
-			OptionType = optionType;
-			OptionValue = optionValue;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitOptionDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[OptionDeclaration OptionType={0} OptionValue={1}]", OptionType, OptionValue);
-		}
-	}
-	
-	public class ParameterDeclarationExpression : Expression {
-		
-		List<AttributeSection> attributes;
-		
-		string parameterName;
-		
-		TypeReference typeReference;
-		
-		ParameterModifiers paramModifier;
-		
-		Expression defaultValue;
-		
-		public List<AttributeSection> Attributes {
-			get {
-				return attributes;
-			}
-			set {
-				attributes = value ?? new List<AttributeSection>();
-			}
-		}
-		
-		public string ParameterName {
-			get {
-				return parameterName;
-			}
-			set {
-				parameterName = string.IsNullOrEmpty(value) ? "?" : value;
-			}
-		}
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public ParameterModifiers ParamModifier {
-			get {
-				return paramModifier;
-			}
-			set {
-				paramModifier = value;
-			}
-		}
-		
-		public Expression DefaultValue {
-			get {
-				return defaultValue;
-			}
-			set {
-				defaultValue = value ?? Expression.Null;
-				if (!defaultValue.IsNull) defaultValue.Parent = this;
-			}
-		}
-		
-		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName) {
-			TypeReference = typeReference;
-			ParameterName = parameterName;
-			attributes = new List<AttributeSection>();
-			defaultValue = Expression.Null;
-		}
-		
-		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParameterModifiers paramModifier) {
-			TypeReference = typeReference;
-			ParameterName = parameterName;
-			ParamModifier = paramModifier;
-			attributes = new List<AttributeSection>();
-			defaultValue = Expression.Null;
-		}
-		
-		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParameterModifiers paramModifier, Expression defaultValue) {
-			TypeReference = typeReference;
-			ParameterName = parameterName;
-			ParamModifier = paramModifier;
-			DefaultValue = defaultValue;
-			attributes = new List<AttributeSection>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitParameterDeclarationExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ParameterDeclarationExpression Attributes={0} ParameterName={1} TypeReference={2" +
-					"} ParamModifier={3} DefaultValue={4}]", GetCollectionString(Attributes), ParameterName, TypeReference, ParamModifier, DefaultValue);
-		}
-	}
-	
-	public abstract class ParametrizedNode : AttributedNode {
-		
-		string name;
-		
-		List<ParameterDeclarationExpression> parameters;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public List<ParameterDeclarationExpression> Parameters {
-			get {
-				return parameters;
-			}
-			set {
-				parameters = value ?? new List<ParameterDeclarationExpression>();
-			}
-		}
-		
-		protected ParametrizedNode() {
-			name = "";
-			parameters = new List<ParameterDeclarationExpression>();
-		}
-		
-		protected ParametrizedNode(Modifiers modifier, List<AttributeSection> attributes, string name, List<ParameterDeclarationExpression> parameters) {
-			Modifier = modifier;
-			Attributes = attributes;
-			Name = name;
-			Parameters = parameters;
-		}
-	}
-	
-	public class ParenthesizedExpression : Expression {
-		
-		Expression expression;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public ParenthesizedExpression(Expression expression) {
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitParenthesizedExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ParenthesizedExpression Expression={0}]", Expression);
-		}
-	}
-	
-	public class PropertyDeclaration : MemberNode {
-		
-		Location bodyStart;
-		
-		Location bodyEnd;
-		
-		PropertyGetRegion getRegion;
-		
-		PropertySetRegion setRegion;
-		
-		Expression initializer;
-		
-		public Location BodyStart {
-			get {
-				return bodyStart;
-			}
-			set {
-				bodyStart = value;
-			}
-		}
-		
-		public Location BodyEnd {
-			get {
-				return bodyEnd;
-			}
-			set {
-				bodyEnd = value;
-			}
-		}
-		
-		public PropertyGetRegion GetRegion {
-			get {
-				return getRegion;
-			}
-			set {
-				getRegion = value ?? PropertyGetRegion.Null;
-				if (!getRegion.IsNull) getRegion.Parent = this;
-			}
-		}
-		
-		public PropertySetRegion SetRegion {
-			get {
-				return setRegion;
-			}
-			set {
-				setRegion = value ?? PropertySetRegion.Null;
-				if (!setRegion.IsNull) setRegion.Parent = this;
-			}
-		}
-		
-		public Expression Initializer {
-			get {
-				return initializer;
-			}
-			set {
-				initializer = value ?? Expression.Null;
-				if (!initializer.IsNull) initializer.Parent = this;
-			}
-		}
-		
-		public PropertyDeclaration(Modifiers modifier, List<AttributeSection> attributes, string name, List<ParameterDeclarationExpression> parameters) {
-			Modifier = modifier;
-			Attributes = attributes;
-			Name = name;
-			Parameters = parameters;
-			bodyStart = Location.Empty;
-			bodyEnd = Location.Empty;
-			getRegion = PropertyGetRegion.Null;
-			setRegion = PropertySetRegion.Null;
-			initializer = Expression.Null;
-		}
-		
-		public bool IsReadOnly {
-			get {
-				return HasGetRegion && !HasSetRegion;
-			}
-		}
-		
-		public bool HasGetRegion {
-			get {
-				return !getRegion.IsNull;
-			}
-		}
-		
-		public bool IsWriteOnly {
-			get {
-				return !HasGetRegion && HasSetRegion;
-			}
-		}
-		
-		public bool IsIndexer {
-			get {
-				return (Modifier & Modifiers.Default) != 0;
-			}
-		}
-		
-
-		internal PropertyDeclaration(string name, TypeReference typeReference, Modifiers modifier, List<AttributeSection> attributes) : this(modifier, attributes, name, null)
-		{
-			this.TypeReference = typeReference;
-			if ((modifier & Modifiers.ReadOnly) != Modifiers.ReadOnly) {
-				this.SetRegion = new PropertySetRegion(null, null);
-			}
-			if ((modifier & Modifiers.WriteOnly) != Modifiers.WriteOnly) {
-				this.GetRegion = new PropertyGetRegion(null, null);
-			}
-		}
-		
-		public bool HasSetRegion {
-			get {
-				return !setRegion.IsNull;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitPropertyDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[PropertyDeclaration BodyStart={0} BodyEnd={1} GetRegion={2} SetRegion={3} Initia" +
-					"lizer={4} InterfaceImplementations={5} TypeReference={6} Name={7} Parameters={8}" +
-					" Attributes={9} Modifier={10}]", BodyStart, BodyEnd, GetRegion, SetRegion, Initializer, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class PropertyGetRegion : PropertyGetSetRegion {
-		
-		public PropertyGetRegion(BlockStatement block, List<AttributeSection> attributes) : 
-				base(block, attributes) {
-		}
-		
-		public static PropertyGetRegion Null {
-			get {
-				return NullPropertyGetRegion.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitPropertyGetRegion(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[PropertyGetRegion Block={0} Attributes={1} Modifier={2}]", Block, GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	internal sealed class NullPropertyGetRegion : PropertyGetRegion {
-		
-		private NullPropertyGetRegion() : 
-				base(null, null) {
-		}
-		
-		internal static NullPropertyGetRegion Instance = new NullPropertyGetRegion();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullPropertyGetRegion]";
-		}
-	}
-	
-	public abstract class PropertyGetSetRegion : AttributedNode, INullable {
-		
-		BlockStatement block;
-		
-		public BlockStatement Block {
-			get {
-				return block;
-			}
-			set {
-				block = value ?? BlockStatement.Null;
-				if (!block.IsNull) block.Parent = this;
-			}
-		}
-		
-		protected PropertyGetSetRegion(BlockStatement block, List<AttributeSection> attributes) {
-			Block = block;
-			Attributes = attributes;
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-	}
-	
-	public class PropertySetRegion : PropertyGetSetRegion {
-		
-		List<ParameterDeclarationExpression> parameters;
-		
-		public List<ParameterDeclarationExpression> Parameters {
-			get {
-				return parameters;
-			}
-			set {
-				parameters = value ?? new List<ParameterDeclarationExpression>();
-			}
-		}
-		
-		public PropertySetRegion(BlockStatement block, List<AttributeSection> attributes) : 
-				base(block, attributes) {
-			parameters = new List<ParameterDeclarationExpression>();
-		}
-		
-		public static PropertySetRegion Null {
-			get {
-				return NullPropertySetRegion.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitPropertySetRegion(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[PropertySetRegion Parameters={0} Block={1} Attributes={2} Modifier={3}]", GetCollectionString(Parameters), Block, GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	internal sealed class NullPropertySetRegion : PropertySetRegion {
-		
-		private NullPropertySetRegion() : 
-				base(null, null) {
-		}
-		
-		internal static NullPropertySetRegion Instance = new NullPropertySetRegion();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullPropertySetRegion]";
-		}
-	}
-	
-	public class QueryExpression : Expression {
-		
-		List<QueryExpressionClause> clauses;
-		
-		public List<QueryExpressionClause> Clauses {
-			get {
-				return clauses;
-			}
-			set {
-				clauses = value ?? new List<QueryExpressionClause>();
-			}
-		}
-		
-		public QueryExpression() {
-			clauses = new List<QueryExpressionClause>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpression Clauses={0}]", GetCollectionString(Clauses));
-		}
-	}
-	
-	public class QueryExpressionAggregateClause : QueryExpressionClause {
-		
-		CollectionRangeVariable source;
-		
-		List<QueryExpressionClause> middleClauses;
-		
-		List<ExpressionRangeVariable> intoVariables;
-		
-		public CollectionRangeVariable Source {
-			get {
-				return source;
-			}
-			set {
-				source = value ?? CollectionRangeVariable.Null;
-				if (!source.IsNull) source.Parent = this;
-			}
-		}
-		
-		public List<QueryExpressionClause> MiddleClauses {
-			get {
-				return middleClauses;
-			}
-			set {
-				middleClauses = value ?? new List<QueryExpressionClause>();
-			}
-		}
-		
-		public List<ExpressionRangeVariable> IntoVariables {
-			get {
-				return intoVariables;
-			}
-			set {
-				intoVariables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public QueryExpressionAggregateClause() {
-			source = CollectionRangeVariable.Null;
-			middleClauses = new List<QueryExpressionClause>();
-			intoVariables = new List<ExpressionRangeVariable>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionAggregateClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionAggregateClause Source={0} MiddleClauses={1} IntoVariables={2}]", Source, GetCollectionString(MiddleClauses), GetCollectionString(IntoVariables));
-		}
-	}
-	
-	public abstract class QueryExpressionClause : AbstractNode, INullable {
-		
-		protected QueryExpressionClause() {
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		public static QueryExpressionClause Null {
-			get {
-				return NullQueryExpressionClause.Instance;
-			}
-		}
-	}
-	
-	internal sealed class NullQueryExpressionClause : QueryExpressionClause {
-		
-		internal static NullQueryExpressionClause Instance = new NullQueryExpressionClause();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullQueryExpressionClause]";
-		}
-	}
-	
-	public class QueryExpressionDistinctClause : QueryExpressionClause {
-		
-		public QueryExpressionDistinctClause() {
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionDistinctClause(this, data);
-		}
-		
-		public override string ToString() {
-			return "[QueryExpressionDistinctClause]";
-		}
-	}
-	
-	public class QueryExpressionFromClause : QueryExpressionClause {
-		
-		List<CollectionRangeVariable> sources;
-		
-		public List<CollectionRangeVariable> Sources {
-			get {
-				return sources;
-			}
-			set {
-				sources = value ?? new List<CollectionRangeVariable>();
-			}
-		}
-		
-		public QueryExpressionFromClause() {
-			sources = new List<CollectionRangeVariable>();
-		}
-		
-		public new static QueryExpressionFromClause Null {
-			get {
-				return NullQueryExpressionFromClause.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionFromClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionFromClause Sources={0}]", GetCollectionString(Sources));
-		}
-	}
-	
-	internal sealed class NullQueryExpressionFromClause : QueryExpressionFromClause {
-		
-		internal static NullQueryExpressionFromClause Instance = new NullQueryExpressionFromClause();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullQueryExpressionFromClause]";
-		}
-	}
-	
-	public class QueryExpressionGroupClause : QueryExpressionClause {
-		
-		Expression projection;
-		
-		Expression groupBy;
-		
-		public Expression Projection {
-			get {
-				return projection;
-			}
-			set {
-				projection = value ?? Expression.Null;
-				if (!projection.IsNull) projection.Parent = this;
-			}
-		}
-		
-		public Expression GroupBy {
-			get {
-				return groupBy;
-			}
-			set {
-				groupBy = value ?? Expression.Null;
-				if (!groupBy.IsNull) groupBy.Parent = this;
-			}
-		}
-		
-		public QueryExpressionGroupClause() {
-			projection = Expression.Null;
-			groupBy = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionGroupClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionGroupClause Projection={0} GroupBy={1}]", Projection, GroupBy);
-		}
-	}
-	
-	public class QueryExpressionGroupJoinVBClause : QueryExpressionClause {
-		
-		QueryExpressionJoinVBClause joinClause;
-		
-		List<ExpressionRangeVariable> intoVariables;
-		
-		public QueryExpressionJoinVBClause JoinClause {
-			get {
-				return joinClause;
-			}
-			set {
-				joinClause = value ?? QueryExpressionJoinVBClause.Null;
-				if (!joinClause.IsNull) joinClause.Parent = this;
-			}
-		}
-		
-		public List<ExpressionRangeVariable> IntoVariables {
-			get {
-				return intoVariables;
-			}
-			set {
-				intoVariables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public QueryExpressionGroupJoinVBClause() {
-			joinClause = QueryExpressionJoinVBClause.Null;
-			intoVariables = new List<ExpressionRangeVariable>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionGroupJoinVBClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionGroupJoinVBClause JoinClause={0} IntoVariables={1}]", JoinClause, GetCollectionString(IntoVariables));
-		}
-	}
-	
-	public class QueryExpressionGroupVBClause : QueryExpressionClause {
-		
-		List<ExpressionRangeVariable> groupVariables;
-		
-		List<ExpressionRangeVariable> byVariables;
-		
-		List<ExpressionRangeVariable> intoVariables;
-		
-		public List<ExpressionRangeVariable> GroupVariables {
-			get {
-				return groupVariables;
-			}
-			set {
-				groupVariables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public List<ExpressionRangeVariable> ByVariables {
-			get {
-				return byVariables;
-			}
-			set {
-				byVariables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public List<ExpressionRangeVariable> IntoVariables {
-			get {
-				return intoVariables;
-			}
-			set {
-				intoVariables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public QueryExpressionGroupVBClause() {
-			groupVariables = new List<ExpressionRangeVariable>();
-			byVariables = new List<ExpressionRangeVariable>();
-			intoVariables = new List<ExpressionRangeVariable>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionGroupVBClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionGroupVBClause GroupVariables={0} ByVariables={1} IntoVariables={2" +
-					"}]", GetCollectionString(GroupVariables), GetCollectionString(ByVariables), GetCollectionString(IntoVariables));
-		}
-	}
-	
-	public class QueryExpressionJoinClause : QueryExpressionClause {
-		
-		Expression onExpression;
-		
-		Expression equalsExpression;
-		
-		CollectionRangeVariable source;
-		
-		string intoIdentifier;
-		
-		public Expression OnExpression {
-			get {
-				return onExpression;
-			}
-			set {
-				onExpression = value ?? Expression.Null;
-				if (!onExpression.IsNull) onExpression.Parent = this;
-			}
-		}
-		
-		public Expression EqualsExpression {
-			get {
-				return equalsExpression;
-			}
-			set {
-				equalsExpression = value ?? Expression.Null;
-				if (!equalsExpression.IsNull) equalsExpression.Parent = this;
-			}
-		}
-		
-		public CollectionRangeVariable Source {
-			get {
-				return source;
-			}
-			set {
-				source = value ?? CollectionRangeVariable.Null;
-				if (!source.IsNull) source.Parent = this;
-			}
-		}
-		
-		public string IntoIdentifier {
-			get {
-				return intoIdentifier;
-			}
-			set {
-				intoIdentifier = value ?? "";
-			}
-		}
-		
-		public QueryExpressionJoinClause() {
-			onExpression = Expression.Null;
-			equalsExpression = Expression.Null;
-			source = CollectionRangeVariable.Null;
-			intoIdentifier = "";
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionJoinClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionJoinClause OnExpression={0} EqualsExpression={1} Source={2} IntoI" +
-					"dentifier={3}]", OnExpression, EqualsExpression, Source, IntoIdentifier);
-		}
-	}
-	
-	public class QueryExpressionJoinConditionVB : AbstractNode {
-		
-		Expression leftSide;
-		
-		Expression rightSide;
-		
-		public Expression LeftSide {
-			get {
-				return leftSide;
-			}
-			set {
-				leftSide = value ?? Expression.Null;
-				if (!leftSide.IsNull) leftSide.Parent = this;
-			}
-		}
-		
-		public Expression RightSide {
-			get {
-				return rightSide;
-			}
-			set {
-				rightSide = value ?? Expression.Null;
-				if (!rightSide.IsNull) rightSide.Parent = this;
-			}
-		}
-		
-		public QueryExpressionJoinConditionVB() {
-			leftSide = Expression.Null;
-			rightSide = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionJoinConditionVB(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionJoinConditionVB LeftSide={0} RightSide={1}]", LeftSide, RightSide);
-		}
-	}
-	
-	public class QueryExpressionJoinVBClause : QueryExpressionClause {
-		
-		CollectionRangeVariable joinVariable;
-		
-		QueryExpressionJoinVBClause subJoin;
-		
-		List<QueryExpressionJoinConditionVB> conditions;
-		
-		public CollectionRangeVariable JoinVariable {
-			get {
-				return joinVariable;
-			}
-			set {
-				joinVariable = value ?? CollectionRangeVariable.Null;
-				if (!joinVariable.IsNull) joinVariable.Parent = this;
-			}
-		}
-		
-		public QueryExpressionJoinVBClause SubJoin {
-			get {
-				return subJoin;
-			}
-			set {
-				subJoin = value ?? QueryExpressionJoinVBClause.Null;
-				if (!subJoin.IsNull) subJoin.Parent = this;
-			}
-		}
-		
-		public List<QueryExpressionJoinConditionVB> Conditions {
-			get {
-				return conditions;
-			}
-			set {
-				conditions = value ?? new List<QueryExpressionJoinConditionVB>();
-			}
-		}
-		
-		public QueryExpressionJoinVBClause() {
-			joinVariable = CollectionRangeVariable.Null;
-			subJoin = QueryExpressionJoinVBClause.Null;
-			conditions = new List<QueryExpressionJoinConditionVB>();
-		}
-		
-		public new static QueryExpressionJoinVBClause Null {
-			get {
-				return NullQueryExpressionJoinVBClause.Instance;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionJoinVBClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionJoinVBClause JoinVariable={0} SubJoin={1} Conditions={2}]", JoinVariable, SubJoin, GetCollectionString(Conditions));
-		}
-	}
-	
-	internal sealed class NullQueryExpressionJoinVBClause : QueryExpressionJoinVBClause {
-		
-		internal static NullQueryExpressionJoinVBClause Instance = new NullQueryExpressionJoinVBClause();
-		
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return null;
-		}
-		
-		public override string ToString() {
-			return "[NullQueryExpressionJoinVBClause]";
-		}
-	}
-	
-	public class QueryExpressionLetClause : QueryExpressionClause {
-		
-		string identifier;
-		
-		Expression expression;
-		
-		public string Identifier {
-			get {
-				return identifier;
-			}
-			set {
-				identifier = string.IsNullOrEmpty(value) ? "?" : value;
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public QueryExpressionLetClause() {
-			identifier = "?";
-			expression = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionLetClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionLetClause Identifier={0} Expression={1}]", Identifier, Expression);
-		}
-	}
-	
-	public class QueryExpressionLetVBClause : QueryExpressionClause {
-		
-		List<ExpressionRangeVariable> variables;
-		
-		public List<ExpressionRangeVariable> Variables {
-			get {
-				return variables;
-			}
-			set {
-				variables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public QueryExpressionLetVBClause() {
-			variables = new List<ExpressionRangeVariable>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionLetVBClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionLetVBClause Variables={0}]", GetCollectionString(Variables));
-		}
-	}
-	
-	public class QueryExpressionOrderClause : QueryExpressionClause {
-		
-		List<QueryExpressionOrdering> orderings;
-		
-		public List<QueryExpressionOrdering> Orderings {
-			get {
-				return orderings;
-			}
-			set {
-				orderings = value ?? new List<QueryExpressionOrdering>();
-			}
-		}
-		
-		public QueryExpressionOrderClause() {
-			orderings = new List<QueryExpressionOrdering>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionOrderClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionOrderClause Orderings={0}]", GetCollectionString(Orderings));
-		}
-	}
-	
-	public class QueryExpressionOrdering : AbstractNode {
-		
-		Expression criteria;
-		
-		QueryExpressionOrderingDirection direction;
-		
-		public Expression Criteria {
-			get {
-				return criteria;
-			}
-			set {
-				criteria = value ?? Expression.Null;
-				if (!criteria.IsNull) criteria.Parent = this;
-			}
-		}
-		
-		public QueryExpressionOrderingDirection Direction {
-			get {
-				return direction;
-			}
-			set {
-				direction = value;
-			}
-		}
-		
-		public QueryExpressionOrdering() {
-			criteria = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionOrdering(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionOrdering Criteria={0} Direction={1}]", Criteria, Direction);
-		}
-	}
-	
-	public class QueryExpressionPartitionVBClause : QueryExpressionClause {
-		
-		Expression expression;
-		
-		QueryExpressionPartitionType partitionType;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public QueryExpressionPartitionType PartitionType {
-			get {
-				return partitionType;
-			}
-			set {
-				partitionType = value;
-			}
-		}
-		
-		public QueryExpressionPartitionVBClause() {
-			expression = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionPartitionVBClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionPartitionVBClause Expression={0} PartitionType={1}]", Expression, PartitionType);
-		}
-	}
-	
-	public class QueryExpressionSelectClause : QueryExpressionClause {
-		
-		Expression projection;
-		
-		public Expression Projection {
-			get {
-				return projection;
-			}
-			set {
-				projection = value ?? Expression.Null;
-				if (!projection.IsNull) projection.Parent = this;
-			}
-		}
-		
-		public QueryExpressionSelectClause() {
-			projection = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionSelectClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionSelectClause Projection={0}]", Projection);
-		}
-	}
-	
-	public class QueryExpressionSelectVBClause : QueryExpressionClause {
-		
-		List<ExpressionRangeVariable> variables;
-		
-		public List<ExpressionRangeVariable> Variables {
-			get {
-				return variables;
-			}
-			set {
-				variables = value ?? new List<ExpressionRangeVariable>();
-			}
-		}
-		
-		public QueryExpressionSelectVBClause() {
-			variables = new List<ExpressionRangeVariable>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionSelectVBClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionSelectVBClause Variables={0}]", GetCollectionString(Variables));
-		}
-	}
-	
-	public class QueryExpressionWhereClause : QueryExpressionClause {
-		
-		Expression condition;
-		
-		public Expression Condition {
-			get {
-				return condition;
-			}
-			set {
-				condition = value ?? Expression.Null;
-				if (!condition.IsNull) condition.Parent = this;
-			}
-		}
-		
-		public QueryExpressionWhereClause() {
-			condition = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitQueryExpressionWhereClause(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[QueryExpressionWhereClause Condition={0}]", Condition);
-		}
-	}
-	
-	public class RaiseEventStatement : Statement {
-		
-		string eventName;
-		
-		List<Expression> arguments;
-		
-		public string EventName {
-			get {
-				return eventName;
-			}
-			set {
-				eventName = value ?? "";
-			}
-		}
-		
-		public List<Expression> Arguments {
-			get {
-				return arguments;
-			}
-			set {
-				arguments = value ?? new List<Expression>();
-			}
-		}
-		
-		public RaiseEventStatement(string eventName, List<Expression> arguments) {
-			EventName = eventName;
-			Arguments = arguments;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitRaiseEventStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[RaiseEventStatement EventName={0} Arguments={1}]", EventName, GetCollectionString(Arguments));
-		}
-	}
-	
-	public class ReDimStatement : Statement {
-		
-		List<InvocationExpression> reDimClauses;
-		
-		bool isPreserve;
-		
-		public List<InvocationExpression> ReDimClauses {
-			get {
-				return reDimClauses;
-			}
-			set {
-				reDimClauses = value ?? new List<InvocationExpression>();
-			}
-		}
-		
-		public bool IsPreserve {
-			get {
-				return isPreserve;
-			}
-			set {
-				isPreserve = value;
-			}
-		}
-		
-		public ReDimStatement(bool isPreserve) {
-			IsPreserve = isPreserve;
-			reDimClauses = new List<InvocationExpression>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitReDimStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ReDimStatement ReDimClauses={0} IsPreserve={1}]", GetCollectionString(ReDimClauses), IsPreserve);
-		}
-	}
-	
-	public class RemoveHandlerStatement : Statement {
-		
-		Expression eventExpression;
-		
-		Expression handlerExpression;
-		
-		public Expression EventExpression {
-			get {
-				return eventExpression;
-			}
-			set {
-				eventExpression = value ?? Expression.Null;
-				if (!eventExpression.IsNull) eventExpression.Parent = this;
-			}
-		}
-		
-		public Expression HandlerExpression {
-			get {
-				return handlerExpression;
-			}
-			set {
-				handlerExpression = value ?? Expression.Null;
-				if (!handlerExpression.IsNull) handlerExpression.Parent = this;
-			}
-		}
-		
-		public RemoveHandlerStatement(Expression eventExpression, Expression handlerExpression) {
-			EventExpression = eventExpression;
-			HandlerExpression = handlerExpression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitRemoveHandlerStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[RemoveHandlerStatement EventExpression={0} HandlerExpression={1}]", EventExpression, HandlerExpression);
-		}
-	}
-	
-	public class ResumeStatement : Statement {
-		
-		string labelName;
-		
-		bool isResumeNext;
-		
-		public string LabelName {
-			get {
-				return labelName;
-			}
-			set {
-				labelName = value ?? "";
-			}
-		}
-		
-		public bool IsResumeNext {
-			get {
-				return isResumeNext;
-			}
-			set {
-				isResumeNext = value;
-			}
-		}
-		
-		public ResumeStatement(bool isResumeNext) {
-			IsResumeNext = isResumeNext;
-			labelName = "";
-		}
-		
-		public ResumeStatement(string labelName) {
-			LabelName = labelName;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitResumeStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ResumeStatement LabelName={0} IsResumeNext={1}]", LabelName, IsResumeNext);
-		}
-	}
-	
-	public class ReturnStatement : Statement {
-		
-		Expression expression;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public ReturnStatement(Expression expression) {
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitReturnStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ReturnStatement Expression={0}]", Expression);
-		}
-	}
-	
-	public class StopStatement : Statement {
-		
-		public StopStatement() {
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitStopStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return "[StopStatement]";
-		}
-	}
-	
-	public class SwitchSection : BlockStatement {
-		
-		List<CaseLabel> switchLabels;
-		
-		public List<CaseLabel> SwitchLabels {
-			get {
-				return switchLabels;
-			}
-			set {
-				switchLabels = value ?? new List<CaseLabel>();
-			}
-		}
-		
-		public SwitchSection() {
-			switchLabels = new List<CaseLabel>();
-		}
-		
-		public SwitchSection(List<CaseLabel> switchLabels) {
-			SwitchLabels = switchLabels;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitSwitchSection(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[SwitchSection SwitchLabels={0}]", GetCollectionString(SwitchLabels));
-		}
-	}
-	
-	public class SwitchStatement : Statement {
-		
-		Expression switchExpression;
-		
-		List<SwitchSection> switchSections;
-		
-		public Expression SwitchExpression {
-			get {
-				return switchExpression;
-			}
-			set {
-				switchExpression = value ?? Expression.Null;
-				if (!switchExpression.IsNull) switchExpression.Parent = this;
-			}
-		}
-		
-		public List<SwitchSection> SwitchSections {
-			get {
-				return switchSections;
-			}
-			set {
-				switchSections = value ?? new List<SwitchSection>();
-			}
-		}
-		
-		public SwitchStatement(Expression switchExpression, List<SwitchSection> switchSections) {
-			SwitchExpression = switchExpression;
-			SwitchSections = switchSections;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitSwitchStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[SwitchStatement SwitchExpression={0} SwitchSections={1}]", SwitchExpression, GetCollectionString(SwitchSections));
-		}
-	}
-	
-	public class TemplateDefinition : AttributedNode {
-		
-		string name;
-		
-		VarianceModifier varianceModifier;
-		
-		List<TypeReference> bases;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = string.IsNullOrEmpty(value) ? "?" : value;
-			}
-		}
-		
-		public VarianceModifier VarianceModifier {
-			get {
-				return varianceModifier;
-			}
-			set {
-				varianceModifier = value;
-			}
-		}
-		
-		public List<TypeReference> Bases {
-			get {
-				return bases;
-			}
-			set {
-				bases = value ?? new List<TypeReference>();
-			}
-		}
-		
-		public TemplateDefinition() {
-			name = "?";
-			bases = new List<TypeReference>();
-		}
-		
-		public TemplateDefinition(string name, List<AttributeSection> attributes) {
-			Name = name;
-			Attributes = attributes;
-			bases = new List<TypeReference>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitTemplateDefinition(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[TemplateDefinition Name={0} VarianceModifier={1} Bases={2} Attributes={3} Modifi" +
-					"er={4}]", Name, VarianceModifier, GetCollectionString(Bases), GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class ThisReferenceExpression : Expression {
-		
-		public ThisReferenceExpression() {
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitThisReferenceExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return "[ThisReferenceExpression]";
-		}
-	}
-	
-	public class ThrowStatement : Statement {
-		
-		Expression expression;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public ThrowStatement(Expression expression) {
-			Expression = expression;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitThrowStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[ThrowStatement Expression={0}]", Expression);
-		}
-	}
-	
-	public class TryCatchStatement : Statement {
-		
-		Statement statementBlock;
-		
-		List<CatchClause> catchClauses;
-		
-		Statement finallyBlock;
-		
-		public Statement StatementBlock {
-			get {
-				return statementBlock;
-			}
-			set {
-				statementBlock = value ?? Statement.Null;
-				if (!statementBlock.IsNull) statementBlock.Parent = this;
-			}
-		}
-		
-		public List<CatchClause> CatchClauses {
-			get {
-				return catchClauses;
-			}
-			set {
-				catchClauses = value ?? new List<CatchClause>();
-			}
-		}
-		
-		public Statement FinallyBlock {
-			get {
-				return finallyBlock;
-			}
-			set {
-				finallyBlock = value ?? Statement.Null;
-				if (!finallyBlock.IsNull) finallyBlock.Parent = this;
-			}
-		}
-		
-		public TryCatchStatement(Statement statementBlock, List<CatchClause> catchClauses, Statement finallyBlock) {
-			StatementBlock = statementBlock;
-			CatchClauses = catchClauses;
-			FinallyBlock = finallyBlock;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitTryCatchStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[TryCatchStatement StatementBlock={0} CatchClauses={1} FinallyBlock={2}]", StatementBlock, GetCollectionString(CatchClauses), FinallyBlock);
-		}
-	}
-	
-	public class TypeDeclaration : AttributedNode {
-		
-		string name;
-		
-		ClassType type;
-		
-		List<TypeReference> baseTypes;
-		
-		List<TemplateDefinition> templates;
-		
-		Location bodyStartLocation;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public ClassType Type {
-			get {
-				return type;
-			}
-			set {
-				type = value;
-			}
-		}
-		
-		public List<TypeReference> BaseTypes {
-			get {
-				return baseTypes;
-			}
-			set {
-				baseTypes = value ?? new List<TypeReference>();
-			}
-		}
-		
-		public List<TemplateDefinition> Templates {
-			get {
-				return templates;
-			}
-			set {
-				templates = value ?? new List<TemplateDefinition>();
-			}
-		}
-		
-		public Location BodyStartLocation {
-			get {
-				return bodyStartLocation;
-			}
-			set {
-				bodyStartLocation = value;
-			}
-		}
-		
-		public TypeDeclaration(Modifiers modifier, List<AttributeSection> attributes) {
-			Modifier = modifier;
-			Attributes = attributes;
-			name = "";
-			baseTypes = new List<TypeReference>();
-			templates = new List<TemplateDefinition>();
-			bodyStartLocation = Location.Empty;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitTypeDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[TypeDeclaration Name={0} Type={1} BaseTypes={2} Templates={3} BodyStartLocation=" +
-					"{4} Attributes={5} Modifier={6}]", Name, Type, GetCollectionString(BaseTypes), GetCollectionString(Templates), BodyStartLocation, GetCollectionString(Attributes), Modifier);
-		}
-	}
-	
-	public class TypeOfExpression : Expression {
-		
-		TypeReference typeReference;
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public TypeOfExpression(TypeReference typeReference) {
-			TypeReference = typeReference;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitTypeOfExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[TypeOfExpression TypeReference={0}]", TypeReference);
-		}
-	}
-	
-	public class TypeOfIsExpression : Expression {
-		
-		Expression expression;
-		
-		TypeReference typeReference;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public TypeOfIsExpression(Expression expression, TypeReference typeReference) {
-			Expression = expression;
-			TypeReference = typeReference;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitTypeOfIsExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[TypeOfIsExpression Expression={0} TypeReference={1}]", Expression, TypeReference);
-		}
-	}
-	
-	public class TypeReferenceExpression : Expression {
-		
-		TypeReference typeReference;
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public TypeReferenceExpression(TypeReference typeReference) {
-			TypeReference = typeReference;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitTypeReferenceExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[TypeReferenceExpression TypeReference={0}]", TypeReference);
-		}
-	}
-	
-	public class UnaryOperatorExpression : Expression {
-		
-		UnaryOperatorType op;
-		
-		Expression expression;
-		
-		public UnaryOperatorType Op {
-			get {
-				return op;
-			}
-			set {
-				op = value;
-			}
-		}
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public UnaryOperatorExpression(UnaryOperatorType op) {
-			Op = op;
-			expression = Expression.Null;
-		}
-		
-		public UnaryOperatorExpression(Expression expression, UnaryOperatorType op) {
-			Expression = expression;
-			Op = op;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitUnaryOperatorExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[UnaryOperatorExpression Op={0} Expression={1}]", Op, Expression);
-		}
-	}
-	
-	public class Using : AbstractNode {
-		
-		string name;
-		
-		TypeReference alias;
-		
-		string xmlPrefix;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = string.IsNullOrEmpty(value) ? "?" : value;
-			}
-		}
-		
-		public TypeReference Alias {
-			get {
-				return alias;
-			}
-			set {
-				alias = value ?? TypeReference.Null;
-				if (!alias.IsNull) alias.Parent = this;
-			}
-		}
-		
-		public string XmlPrefix {
-			get {
-				return xmlPrefix;
-			}
-			set {
-				xmlPrefix = value ?? "";
-			}
-		}
-		
-		public Using(string name) {
-			Name = name;
-			alias = TypeReference.Null;
-			xmlPrefix = "";
-		}
-		
-		public Using(string name, TypeReference alias) {
-			Name = name;
-			Alias = alias;
-			xmlPrefix = "";
-		}
-		
-		public Using(string name, string xmlPrefix) {
-			Name = name;
-			XmlPrefix = xmlPrefix;
-			alias = TypeReference.Null;
-		}
-		
-		public bool IsXml {
-			get {
-				return xmlPrefix != null;
-			}
-		}
-		
-		public bool IsAlias {
-			get {
-				return !alias.IsNull;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitUsing(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[Using Name={0} Alias={1} XmlPrefix={2}]", Name, Alias, XmlPrefix);
-		}
-	}
-	
-	public class UsingDeclaration : AbstractNode {
-		
-		List<Using> usings;
-		
-		public List<Using> Usings {
-			get {
-				return usings;
-			}
-			set {
-				usings = value ?? new List<Using>();
-			}
-		}
-		
-		public UsingDeclaration(List<Using> usings) {
-			Usings = usings;
-		}
-		
-public UsingDeclaration(string xmlNamespace, string prefix) { usings = new List<Using>(1); usings.Add(new Using(xmlNamespace, prefix)); }
-		
-public UsingDeclaration(string @namespace) : this(@namespace, TypeReference.Null) {}
-		
-public UsingDeclaration(string @namespace, TypeReference alias) { usings = new List<Using>(1); usings.Add(new Using(@namespace, alias)); }
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitUsingDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[UsingDeclaration Usings={0}]", GetCollectionString(Usings));
-		}
-	}
-	
-	public class UsingStatement : StatementWithEmbeddedStatement {
-		
-		Statement resourceAcquisition;
-		
-		public Statement ResourceAcquisition {
-			get {
-				return resourceAcquisition;
-			}
-			set {
-				resourceAcquisition = value ?? Statement.Null;
-				if (!resourceAcquisition.IsNull) resourceAcquisition.Parent = this;
-			}
-		}
-		
-		public UsingStatement(Statement resourceAcquisition, Statement embeddedStatement) {
-			ResourceAcquisition = resourceAcquisition;
-			EmbeddedStatement = embeddedStatement;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitUsingStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[UsingStatement ResourceAcquisition={0} EmbeddedStatement={1}]", ResourceAcquisition, EmbeddedStatement);
-		}
-	}
-	
-	public class VariableDeclaration : AbstractNode {
-		
-		string name;
-		
-		Expression initializer;
-		
-		TypeReference typeReference;
-		
-		Expression fixedArrayInitialization;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public Expression Initializer {
-			get {
-				return initializer;
-			}
-			set {
-				initializer = value ?? Expression.Null;
-				if (!initializer.IsNull) initializer.Parent = this;
-			}
-		}
-		
-		public TypeReference TypeReference {
-			get {
-				return typeReference;
-			}
-			set {
-				typeReference = value ?? TypeReference.Null;
-				if (!typeReference.IsNull) typeReference.Parent = this;
-			}
-		}
-		
-		public Expression FixedArrayInitialization {
-			get {
-				return fixedArrayInitialization;
-			}
-			set {
-				fixedArrayInitialization = value ?? Expression.Null;
-				if (!fixedArrayInitialization.IsNull) fixedArrayInitialization.Parent = this;
-			}
-		}
-		
-		public VariableDeclaration(string name) {
-			Name = name;
-			initializer = Expression.Null;
-			typeReference = TypeReference.Null;
-			fixedArrayInitialization = Expression.Null;
-		}
-		
-		public VariableDeclaration(string name, Expression initializer) {
-			Name = name;
-			Initializer = initializer;
-			typeReference = TypeReference.Null;
-			fixedArrayInitialization = Expression.Null;
-		}
-		
-		public VariableDeclaration(string name, Expression initializer, TypeReference typeReference) {
-			Name = name;
-			Initializer = initializer;
-			TypeReference = typeReference;
-			fixedArrayInitialization = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitVariableDeclaration(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[VariableDeclaration Name={0} Initializer={1} TypeReference={2} FixedArrayInitial" +
-					"ization={3}]", Name, Initializer, TypeReference, FixedArrayInitialization);
-		}
-	}
-	
-	public class WithStatement : Statement {
-		
-		Expression expression;
-		
-		BlockStatement body;
-		
-		public Expression Expression {
-			get {
-				return expression;
-			}
-			set {
-				expression = value ?? Expression.Null;
-				if (!expression.IsNull) expression.Parent = this;
-			}
-		}
-		
-		public BlockStatement Body {
-			get {
-				return body;
-			}
-			set {
-				body = value ?? BlockStatement.Null;
-				if (!body.IsNull) body.Parent = this;
-			}
-		}
-		
-		public WithStatement(Expression expression) {
-			Expression = expression;
-			body = BlockStatement.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitWithStatement(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[WithStatement Expression={0} Body={1}]", Expression, Body);
-		}
-	}
-	
-	public class XmlAttributeExpression : XmlExpression {
-		
-		string name;
-		
-		string literalValue;
-		
-		bool useDoubleQuotes;
-		
-		Expression expressionValue;
-		
-		public string Name {
-			get {
-				return name;
-			}
-			set {
-				name = value ?? "";
-			}
-		}
-		
-		public string LiteralValue {
-			get {
-				return literalValue;
-			}
-			set {
-				literalValue = value ?? "";
-			}
-		}
-		
-		public bool UseDoubleQuotes {
-			get {
-				return useDoubleQuotes;
-			}
-			set {
-				useDoubleQuotes = value;
-			}
-		}
-		
-		public Expression ExpressionValue {
-			get {
-				return expressionValue;
-			}
-			set {
-				expressionValue = value ?? Expression.Null;
-				if (!expressionValue.IsNull) expressionValue.Parent = this;
-			}
-		}
-		
-		public XmlAttributeExpression() {
-			name = "";
-			literalValue = "";
-			expressionValue = Expression.Null;
-		}
-		
-		public bool IsLiteralValue {
-			get {
-				return expressionValue.IsNull;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlAttributeExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlAttributeExpression Name={0} LiteralValue={1} UseDoubleQuotes={2} ExpressionV" +
-					"alue={3}]", Name, LiteralValue, UseDoubleQuotes, ExpressionValue);
-		}
-	}
-	
-	public class XmlContentExpression : XmlExpression {
-		
-		string content;
-		
-		XmlContentType type;
-		
-		public string Content {
-			get {
-				return content;
-			}
-			set {
-				content = value ?? "";
-			}
-		}
-		
-		public XmlContentType Type {
-			get {
-				return type;
-			}
-			set {
-				type = value;
-			}
-		}
-		
-		public XmlContentExpression(string content, XmlContentType type) {
-			Content = content;
-			Type = type;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlContentExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlContentExpression Content={0} Type={1}]", Content, Type);
-		}
-	}
-	
-	public class XmlDocumentExpression : XmlExpression {
-		
-		List<XmlExpression> expressions;
-		
-		public List<XmlExpression> Expressions {
-			get {
-				return expressions;
-			}
-			set {
-				expressions = value ?? new List<XmlExpression>();
-			}
-		}
-		
-		public XmlDocumentExpression() {
-			expressions = new List<XmlExpression>();
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlDocumentExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlDocumentExpression Expressions={0}]", GetCollectionString(Expressions));
-		}
-	}
-	
-	public class XmlElementExpression : XmlExpression {
-		
-		Expression content;
-		
-		Expression nameExpression;
-		
-		string xmlName;
-		
-		List<XmlExpression> attributes;
-		
-		public Expression Content {
-			get {
-				return content;
-			}
-			set {
-				content = value ?? Expression.Null;
-				if (!content.IsNull) content.Parent = this;
-			}
-		}
-		
-		public Expression NameExpression {
-			get {
-				return nameExpression;
-			}
-			set {
-				nameExpression = value ?? Expression.Null;
-				if (!nameExpression.IsNull) nameExpression.Parent = this;
-			}
-		}
-		
-		public string XmlName {
-			get {
-				return xmlName;
-			}
-			set {
-				xmlName = value ?? "";
-			}
-		}
-		
-		public List<XmlExpression> Attributes {
-			get {
-				return attributes;
-			}
-			set {
-				attributes = value ?? new List<XmlExpression>();
-			}
-		}
-		
-		public XmlElementExpression() {
-			content = Expression.Null;
-			nameExpression = Expression.Null;
-			xmlName = "";
-			attributes = new List<XmlExpression>();
-		}
-		
-		public bool IsExpression {
-			get {
-				return !content.IsNull;
-			}
-		}
-		
-		public bool NameIsExpression {
-			get {
-				return !nameExpression.IsNull;
-			}
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlElementExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlElementExpression Content={0} NameExpression={1} XmlName={2} Attributes={3}]", Content, NameExpression, XmlName, GetCollectionString(Attributes));
-		}
-	}
-	
-	public class XmlEmbeddedExpression : XmlExpression {
-		
-		Expression inlineVBExpression;
-		
-		public Expression InlineVBExpression {
-			get {
-				return inlineVBExpression;
-			}
-			set {
-				inlineVBExpression = value ?? Expression.Null;
-				if (!inlineVBExpression.IsNull) inlineVBExpression.Parent = this;
-			}
-		}
-		
-		public XmlEmbeddedExpression() {
-			inlineVBExpression = Expression.Null;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlEmbeddedExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlEmbeddedExpression InlineVBExpression={0}]", InlineVBExpression);
-		}
-	}
-	
-	public abstract class XmlExpression : Expression {
-		
-		protected XmlExpression() {
-		}
-	}
-	
-	public class XmlMemberAccessExpression : Expression {
-		
-		Expression targetObject;
-		
-		XmlAxisType axisType;
-		
-		bool isXmlIdentifier;
-		
-		string identifier;
-		
-		public Expression TargetObject {
-			get {
-				return targetObject;
-			}
-			set {
-				targetObject = value ?? Expression.Null;
-				if (!targetObject.IsNull) targetObject.Parent = this;
-			}
-		}
-		
-		public XmlAxisType AxisType {
-			get {
-				return axisType;
-			}
-			set {
-				axisType = value;
-			}
-		}
-		
-		public bool IsXmlIdentifier {
-			get {
-				return isXmlIdentifier;
-			}
-			set {
-				isXmlIdentifier = value;
-			}
-		}
-		
-		public string Identifier {
-			get {
-				return identifier;
-			}
-			set {
-				identifier = value ?? "";
-			}
-		}
-		
-		public XmlMemberAccessExpression(Expression targetObject, XmlAxisType axisType, string identifier, bool isXmlIdentifier) {
-			TargetObject = targetObject;
-			AxisType = axisType;
-			Identifier = identifier;
-			IsXmlIdentifier = isXmlIdentifier;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data) {
-			return visitor.VisitXmlMemberAccessExpression(this, data);
-		}
-		
-		public override string ToString() {
-			return string.Format("[XmlMemberAccessExpression TargetObject={0} AxisType={1} IsXmlIdentifier={2} Iden" +
-					"tifier={3}]", TargetObject, AxisType, IsXmlIdentifier, Identifier);
-		}
-	}
-}
+//namespace ICSharpCode.NRefactory.VB.Ast {
+//	public class AddHandlerStatement : Statement {
+//		
+//		Expression eventExpression;
+//		
+//		Expression handlerExpression;
+//		
+//		public Expression EventExpression {
+//			get {
+//				return eventExpression;
+//			}
+//			set {
+//				eventExpression = value ?? Expression.Null;
+//				if (!eventExpression.IsNull) eventExpression.Parent = this;
+//			}
+//		}
+//		
+//		public Expression HandlerExpression {
+//			get {
+//				return handlerExpression;
+//			}
+//			set {
+//				handlerExpression = value ?? Expression.Null;
+//				if (!handlerExpression.IsNull) handlerExpression.Parent = this;
+//			}
+//		}
+//		
+//		public AddHandlerStatement(Expression eventExpression, Expression handlerExpression) {
+//			EventExpression = eventExpression;
+//			HandlerExpression = handlerExpression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitAddHandlerStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[AddHandlerStatement EventExpression={0} HandlerExpression={1}]", EventExpression, HandlerExpression);
+//		}
+//	}
+//	
+//	public class AddressOfExpression : Expression {
+//		
+//		Expression expression;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public AddressOfExpression(Expression expression) {
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitAddressOfExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[AddressOfExpression Expression={0}]", Expression);
+//		}
+//	}
+//	
+//	public class ArrayCreateExpression : Expression {
+//		
+//		TypeReference createType;
+//		
+//		List<Expression> arguments;
+//		
+//		CollectionInitializerExpression arrayInitializer;
+//		
+//		public TypeReference CreateType {
+//			get {
+//				return createType;
+//			}
+//			set {
+//				createType = value ?? TypeReference.Null;
+//				if (!createType.IsNull) createType.Parent = this;
+//			}
+//		}
+//		
+//		public List<Expression> Arguments {
+//			get {
+//				return arguments;
+//			}
+//			set {
+//				arguments = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public CollectionInitializerExpression ArrayInitializer {
+//			get {
+//				return arrayInitializer;
+//			}
+//			set {
+//				arrayInitializer = value ?? CollectionInitializerExpression.Null;
+//				if (!arrayInitializer.IsNull) arrayInitializer.Parent = this;
+//			}
+//		}
+//		
+//		public ArrayCreateExpression(TypeReference createType) {
+//			CreateType = createType;
+//			arguments = new List<Expression>();
+//			arrayInitializer = CollectionInitializerExpression.Null;
+//		}
+//		
+//		public ArrayCreateExpression(TypeReference createType, List<Expression> arguments) {
+//			CreateType = createType;
+//			Arguments = arguments;
+//			arrayInitializer = CollectionInitializerExpression.Null;
+//		}
+//		
+//		public ArrayCreateExpression(TypeReference createType, CollectionInitializerExpression arrayInitializer) {
+//			CreateType = createType;
+//			ArrayInitializer = arrayInitializer;
+//			arguments = new List<Expression>();
+//		}
+//		
+//		public bool IsImplicitlyTyped {
+//			get {
+//				return createType.IsNull || string.IsNullOrEmpty(createType.Type);
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitArrayCreateExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ArrayCreateExpression CreateType={0} Arguments={1} ArrayInitializer={2}]", CreateType, GetCollectionString(Arguments), ArrayInitializer);
+//		}
+//	}
+//	
+//	public class AssignmentExpression : Expression {
+//		
+//		Expression left;
+//		
+//		AssignmentOperatorType op;
+//		
+//		Expression right;
+//		
+//		public Expression Left {
+//			get {
+//				return left;
+//			}
+//			set {
+//				left = value ?? Expression.Null;
+//				if (!left.IsNull) left.Parent = this;
+//			}
+//		}
+//		
+//		public AssignmentOperatorType Op {
+//			get {
+//				return op;
+//			}
+//			set {
+//				op = value;
+//			}
+//		}
+//		
+//		public Expression Right {
+//			get {
+//				return right;
+//			}
+//			set {
+//				right = value ?? Expression.Null;
+//				if (!right.IsNull) right.Parent = this;
+//			}
+//		}
+//		
+//		public AssignmentExpression(Expression left, AssignmentOperatorType op, Expression right) {
+//			Left = left;
+//			Op = op;
+//			Right = right;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitAssignmentExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[AssignmentExpression Left={0} Op={1} Right={2}]", Left, Op, Right);
+//		}
+//	}
+//	
+//	public abstract class AttributedNode : AbstractNode {
+//		
+//		List<AttributeSection> attributes;
+//		
+//		Modifiers modifier;
+//		
+//		public List<AttributeSection> Attributes {
+//			get {
+//				return attributes;
+//			}
+//			set {
+//				attributes = value ?? new List<AttributeSection>();
+//			}
+//		}
+//		
+//		public Modifiers Modifier {
+//			get {
+//				return modifier;
+//			}
+//			set {
+//				modifier = value;
+//			}
+//		}
+//		
+//		protected AttributedNode() {
+//			attributes = new List<AttributeSection>();
+//		}
+//		
+//		protected AttributedNode(List<AttributeSection> attributes) {
+//			Attributes = attributes;
+//		}
+//		
+//		protected AttributedNode(Modifiers modifier, List<AttributeSection> attributes) {
+//			Modifier = modifier;
+//			Attributes = attributes;
+//		}
+//	}
+//	
+//	public class AttributeSection : AbstractNode {
+//		
+//		string attributeTarget;
+//		
+//		List<ICSharpCode.NRefactory.VB.Ast.Attribute> attributes;
+//		
+//		public string AttributeTarget {
+//			get {
+//				return attributeTarget;
+//			}
+//			set {
+//				attributeTarget = value ?? "";
+//			}
+//		}
+//		
+//		public List<ICSharpCode.NRefactory.VB.Ast.Attribute> Attributes {
+//			get {
+//				return attributes;
+//			}
+//			set {
+//				attributes = value ?? new List<Attribute>();
+//			}
+//		}
+//		
+//		public AttributeSection() {
+//			attributeTarget = "";
+//			attributes = new List<Attribute>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitAttributeSection(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[AttributeSection AttributeTarget={0} Attributes={1}]", AttributeTarget, GetCollectionString(Attributes));
+//		}
+//	}
+//	
+//	public class BaseReferenceExpression : Expression {
+//		
+//		public BaseReferenceExpression() {
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitBaseReferenceExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return "[BaseReferenceExpression]";
+//		}
+//	}
+//	
+//	public class BinaryOperatorExpression : Expression {
+//		
+//		Expression left;
+//		
+//		BinaryOperatorType op;
+//		
+//		Expression right;
+//		
+//		public Expression Left {
+//			get {
+//				return left;
+//			}
+//			set {
+//				left = value ?? Expression.Null;
+//				if (!left.IsNull) left.Parent = this;
+//			}
+//		}
+//		
+//		public BinaryOperatorType Op {
+//			get {
+//				return op;
+//			}
+//			set {
+//				op = value;
+//			}
+//		}
+//		
+//		public Expression Right {
+//			get {
+//				return right;
+//			}
+//			set {
+//				right = value ?? Expression.Null;
+//				if (!right.IsNull) right.Parent = this;
+//			}
+//		}
+//		
+//		public BinaryOperatorExpression() {
+//			left = Expression.Null;
+//			right = Expression.Null;
+//		}
+//		
+//		public BinaryOperatorExpression(Expression left, BinaryOperatorType op, Expression right) {
+//			Left = left;
+//			Op = op;
+//			Right = right;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitBinaryOperatorExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[BinaryOperatorExpression Left={0} Op={1} Right={2}]", Left, Op, Right);
+//		}
+//	}
+//	
+//	public class CaseLabel : AbstractNode {
+//		
+//		Expression label;
+//		
+//		BinaryOperatorType binaryOperatorType;
+//		
+//		Expression toExpression;
+//		
+//		public Expression Label {
+//			get {
+//				return label;
+//			}
+//			set {
+//				label = value ?? Expression.Null;
+//				if (!label.IsNull) label.Parent = this;
+//			}
+//		}
+//		
+//		public BinaryOperatorType BinaryOperatorType {
+//			get {
+//				return binaryOperatorType;
+//			}
+//			set {
+//				binaryOperatorType = value;
+//			}
+//		}
+//		
+//		public Expression ToExpression {
+//			get {
+//				return toExpression;
+//			}
+//			set {
+//				toExpression = value ?? Expression.Null;
+//				if (!toExpression.IsNull) toExpression.Parent = this;
+//			}
+//		}
+//		
+//		public CaseLabel() {
+//			label = Expression.Null;
+//			toExpression = Expression.Null;
+//		}
+//		
+//		public CaseLabel(Expression label) {
+//			Label = label;
+//			toExpression = Expression.Null;
+//		}
+//		
+//		public CaseLabel(Expression label, Expression toExpression) {
+//			Label = label;
+//			ToExpression = toExpression;
+//		}
+//		
+//		public CaseLabel(BinaryOperatorType binaryOperatorType, Expression label) {
+//			BinaryOperatorType = binaryOperatorType;
+//			Label = label;
+//			toExpression = Expression.Null;
+//		}
+//		
+//		public bool IsDefault {
+//			get {
+//				return label.IsNull;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitCaseLabel(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[CaseLabel Label={0} BinaryOperatorType={1} ToExpression={2}]", Label, BinaryOperatorType, ToExpression);
+//		}
+//	}
+//	
+//	public class CastExpression : Expression {
+//		
+//		TypeReference castTo;
+//		
+//		Expression expression;
+//		
+//		CastType castType;
+//		
+//		public TypeReference CastTo {
+//			get {
+//				return castTo;
+//			}
+//			set {
+//				castTo = value ?? TypeReference.Null;
+//				if (!castTo.IsNull) castTo.Parent = this;
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public CastType CastType {
+//			get {
+//				return castType;
+//			}
+//			set {
+//				castType = value;
+//			}
+//		}
+//		
+//		public CastExpression(TypeReference castTo) {
+//			CastTo = castTo;
+//			expression = Expression.Null;
+//		}
+//		
+//		public CastExpression(TypeReference castTo, Expression expression, CastType castType) {
+//			CastTo = castTo;
+//			Expression = expression;
+//			CastType = castType;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitCastExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[CastExpression CastTo={0} Expression={1} CastType={2}]", CastTo, Expression, CastType);
+//		}
+//	}
+//	
+//	public class CatchClause : AbstractNode {
+//		
+//		TypeReference typeReference;
+//		
+//		string variableName;
+//		
+//		Statement statementBlock;
+//		
+//		Expression condition;
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public string VariableName {
+//			get {
+//				return variableName;
+//			}
+//			set {
+//				variableName = value ?? "";
+//			}
+//		}
+//		
+//		public Statement StatementBlock {
+//			get {
+//				return statementBlock;
+//			}
+//			set {
+//				statementBlock = value ?? Statement.Null;
+//				if (!statementBlock.IsNull) statementBlock.Parent = this;
+//			}
+//		}
+//		
+//		public Expression Condition {
+//			get {
+//				return condition;
+//			}
+//			set {
+//				condition = value ?? Expression.Null;
+//				if (!condition.IsNull) condition.Parent = this;
+//			}
+//		}
+//		
+//		public CatchClause(TypeReference typeReference, string variableName, Statement statementBlock) {
+//			TypeReference = typeReference;
+//			VariableName = variableName;
+//			StatementBlock = statementBlock;
+//			condition = Expression.Null;
+//		}
+//		
+//		public CatchClause(TypeReference typeReference, string variableName, Statement statementBlock, Expression condition) {
+//			TypeReference = typeReference;
+//			VariableName = variableName;
+//			StatementBlock = statementBlock;
+//			Condition = condition;
+//		}
+//		
+//		public CatchClause(Statement statementBlock) {
+//			StatementBlock = statementBlock;
+//			typeReference = TypeReference.Null;
+//			variableName = "";
+//			condition = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitCatchClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[CatchClause TypeReference={0} VariableName={1} StatementBlock={2} Condition={3}]" +
+//			                     "", TypeReference, VariableName, StatementBlock, Condition);
+//		}
+//	}
+//	
+//	public class ClassReferenceExpression : Expression {
+//		
+//		public ClassReferenceExpression() {
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitClassReferenceExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return "[ClassReferenceExpression]";
+//		}
+//	}
+//	
+//	public class CollectionInitializerExpression : Expression {
+//		
+//		List<Expression> createExpressions;
+//		
+//		public List<Expression> CreateExpressions {
+//			get {
+//				return createExpressions;
+//			}
+//			set {
+//				createExpressions = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public CollectionInitializerExpression() {
+//			createExpressions = new List<Expression>();
+//		}
+//		
+//		public CollectionInitializerExpression(List<Expression> createExpressions) {
+//			CreateExpressions = createExpressions;
+//		}
+//		
+//		public new static CollectionInitializerExpression Null {
+//			get {
+//				return NullCollectionInitializerExpression.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitCollectionInitializerExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[CollectionInitializerExpression CreateExpressions={0}]", GetCollectionString(CreateExpressions));
+//		}
+//	}
+//	
+//	internal sealed class NullCollectionInitializerExpression : CollectionInitializerExpression {
+//		
+//		internal static NullCollectionInitializerExpression Instance = new NullCollectionInitializerExpression();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullCollectionInitializerExpression]";
+//		}
+//	}
+//	
+//	public class CollectionRangeVariable : AbstractNode, INullable {
+//		
+//		string identifier;
+//		
+//		Expression expression;
+//		
+//		TypeReference type;
+//		
+//		public string Identifier {
+//			get {
+//				return identifier;
+//			}
+//			set {
+//				identifier = value ?? "";
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public TypeReference Type {
+//			get {
+//				return type;
+//			}
+//			set {
+//				type = value ?? TypeReference.Null;
+//				if (!type.IsNull) type.Parent = this;
+//			}
+//		}
+//		
+//		public CollectionRangeVariable() {
+//			identifier = "";
+//			expression = Expression.Null;
+//			type = TypeReference.Null;
+//		}
+//		
+//		public virtual bool IsNull {
+//			get {
+//				return false;
+//			}
+//		}
+//		
+//		public static CollectionRangeVariable Null {
+//			get {
+//				return NullCollectionRangeVariable.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitCollectionRangeVariable(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[CollectionRangeVariable Identifier={0} Expression={1} Type={2}]", Identifier, Expression, Type);
+//		}
+//	}
+//	
+//	internal sealed class NullCollectionRangeVariable : CollectionRangeVariable {
+//		
+//		internal static NullCollectionRangeVariable Instance = new NullCollectionRangeVariable();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullCollectionRangeVariable]";
+//		}
+//	}
+//	
+//	public class ConditionalExpression : Expression {
+//		
+//		Expression condition;
+//		
+//		Expression trueExpression;
+//		
+//		Expression falseExpression;
+//		
+//		public Expression Condition {
+//			get {
+//				return condition;
+//			}
+//			set {
+//				condition = value ?? Expression.Null;
+//				if (!condition.IsNull) condition.Parent = this;
+//			}
+//		}
+//		
+//		public Expression TrueExpression {
+//			get {
+//				return trueExpression;
+//			}
+//			set {
+//				trueExpression = value ?? Expression.Null;
+//				if (!trueExpression.IsNull) trueExpression.Parent = this;
+//			}
+//		}
+//		
+//		public Expression FalseExpression {
+//			get {
+//				return falseExpression;
+//			}
+//			set {
+//				falseExpression = value ?? Expression.Null;
+//				if (!falseExpression.IsNull) falseExpression.Parent = this;
+//			}
+//		}
+//		
+//		public ConditionalExpression() {
+//			condition = Expression.Null;
+//			trueExpression = Expression.Null;
+//			falseExpression = Expression.Null;
+//		}
+//		
+//		public ConditionalExpression(Expression condition, Expression trueExpression, Expression falseExpression) {
+//			Condition = condition;
+//			TrueExpression = trueExpression;
+//			FalseExpression = falseExpression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitConditionalExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ConditionalExpression Condition={0} TrueExpression={1} FalseExpression={2}]", Condition, TrueExpression, FalseExpression);
+//		}
+//	}
+//	
+//	public class ConstructorDeclaration : ParametrizedNode {
+//		
+//		ConstructorInitializer constructorInitializer;
+//		
+//		BlockStatement body;
+//		
+//		public ConstructorInitializer ConstructorInitializer {
+//			get {
+//				return constructorInitializer;
+//			}
+//			set {
+//				constructorInitializer = value ?? ConstructorInitializer.Null;
+//				if (!constructorInitializer.IsNull) constructorInitializer.Parent = this;
+//			}
+//		}
+//		
+//		public BlockStatement Body {
+//			get {
+//				return body;
+//			}
+//			set {
+//				body = value ?? BlockStatement.Null;
+//				if (!body.IsNull) body.Parent = this;
+//			}
+//		}
+//		
+//		public ConstructorDeclaration(string name, Modifiers modifier, List<ParameterDeclarationExpression> parameters, List<AttributeSection> attributes) {
+//			Name = name;
+//			Modifier = modifier;
+//			Parameters = parameters;
+//			Attributes = attributes;
+//			constructorInitializer = ConstructorInitializer.Null;
+//			body = BlockStatement.Null;
+//		}
+//		
+//		public ConstructorDeclaration(string name, Modifiers modifier, List<ParameterDeclarationExpression> parameters, ConstructorInitializer constructorInitializer, List<AttributeSection> attributes) {
+//			Name = name;
+//			Modifier = modifier;
+//			Parameters = parameters;
+//			ConstructorInitializer = constructorInitializer;
+//			Attributes = attributes;
+//			body = BlockStatement.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitConstructorDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ConstructorDeclaration ConstructorInitializer={0} Body={1} Name={2} Parameters={" +
+//			                     "3} Attributes={4} Modifier={5}]", ConstructorInitializer, Body, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class ConstructorInitializer : AbstractNode, INullable {
+//		
+//		ConstructorInitializerType constructorInitializerType;
+//		
+//		List<Expression> arguments;
+//		
+//		public ConstructorInitializerType ConstructorInitializerType {
+//			get {
+//				return constructorInitializerType;
+//			}
+//			set {
+//				constructorInitializerType = value;
+//			}
+//		}
+//		
+//		public List<Expression> Arguments {
+//			get {
+//				return arguments;
+//			}
+//			set {
+//				arguments = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public ConstructorInitializer() {
+//			arguments = new List<Expression>();
+//		}
+//		
+//		public virtual bool IsNull {
+//			get {
+//				return false;
+//			}
+//		}
+//		
+//		public static ConstructorInitializer Null {
+//			get {
+//				return NullConstructorInitializer.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitConstructorInitializer(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ConstructorInitializer ConstructorInitializerType={0} Arguments={1}]", ConstructorInitializerType, GetCollectionString(Arguments));
+//		}
+//	}
+//	
+//	internal sealed class NullConstructorInitializer : ConstructorInitializer {
+//		
+//		internal static NullConstructorInitializer Instance = new NullConstructorInitializer();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullConstructorInitializer]";
+//		}
+//	}
+//	
+//	public class ContinueStatement : Statement {
+//		
+//		ContinueType continueType;
+//		
+//		public ContinueType ContinueType {
+//			get {
+//				return continueType;
+//			}
+//			set {
+//				continueType = value;
+//			}
+//		}
+//		
+//		public ContinueStatement() {
+//		}
+//		
+//		public ContinueStatement(ContinueType continueType) {
+//			ContinueType = continueType;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitContinueStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ContinueStatement ContinueType={0}]", ContinueType);
+//		}
+//	}
+//	
+//	public class DeclareDeclaration : ParametrizedNode {
+//		
+//		string alias;
+//		
+//		string library;
+//		
+//		CharsetModifier charset;
+//		
+//		TypeReference typeReference;
+//		
+//		public string Alias {
+//			get {
+//				return alias;
+//			}
+//			set {
+//				alias = value ?? "";
+//			}
+//		}
+//		
+//		public string Library {
+//			get {
+//				return library;
+//			}
+//			set {
+//				library = value ?? "";
+//			}
+//		}
+//		
+//		public CharsetModifier Charset {
+//			get {
+//				return charset;
+//			}
+//			set {
+//				charset = value;
+//			}
+//		}
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public DeclareDeclaration(string name, Modifiers modifier, TypeReference typeReference, List<ParameterDeclarationExpression> parameters, List<AttributeSection> attributes, string library, string alias, CharsetModifier charset) {
+//			Name = name;
+//			Modifier = modifier;
+//			TypeReference = typeReference;
+//			Parameters = parameters;
+//			Attributes = attributes;
+//			Library = library;
+//			Alias = alias;
+//			Charset = charset;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitDeclareDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[DeclareDeclaration Alias={0} Library={1} Charset={2} TypeReference={3} Name={4} " +
+//			                     "Parameters={5} Attributes={6} Modifier={7}]", Alias, Library, Charset, TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class DefaultValueExpression : Expression {
+//		
+//		TypeReference typeReference;
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public DefaultValueExpression(TypeReference typeReference) {
+//			TypeReference = typeReference;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitDefaultValueExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[DefaultValueExpression TypeReference={0}]", TypeReference);
+//		}
+//	}
+//	
+//	public class DelegateDeclaration : AttributedNode {
+//		
+//		string name;
+//		
+//		TypeReference returnType;
+//		
+//		List<ParameterDeclarationExpression> parameters;
+//		
+//		List<TemplateDefinition> templates;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = string.IsNullOrEmpty(value) ? "?" : value;
+//			}
+//		}
+//		
+//		public TypeReference ReturnType {
+//			get {
+//				return returnType;
+//			}
+//			set {
+//				returnType = value ?? TypeReference.Null;
+//				if (!returnType.IsNull) returnType.Parent = this;
+//			}
+//		}
+//		
+//		public List<ParameterDeclarationExpression> Parameters {
+//			get {
+//				return parameters;
+//			}
+//			set {
+//				parameters = value ?? new List<ParameterDeclarationExpression>();
+//			}
+//		}
+//		
+//		public List<TemplateDefinition> Templates {
+//			get {
+//				return templates;
+//			}
+//			set {
+//				templates = value ?? new List<TemplateDefinition>();
+//			}
+//		}
+//		
+//		public DelegateDeclaration(Modifiers modifier, List<AttributeSection> attributes) {
+//			Modifier = modifier;
+//			Attributes = attributes;
+//			name = "?";
+//			returnType = TypeReference.Null;
+//			parameters = new List<ParameterDeclarationExpression>();
+//			templates = new List<TemplateDefinition>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitDelegateDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[DelegateDeclaration Name={0} ReturnType={1} Parameters={2} Templates={3} Attribu" +
+//			                     "tes={4} Modifier={5}]", Name, ReturnType, GetCollectionString(Parameters), GetCollectionString(Templates), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class DirectionExpression : Expression {
+//		
+//		FieldDirection fieldDirection;
+//		
+//		Expression expression;
+//		
+//		public FieldDirection FieldDirection {
+//			get {
+//				return fieldDirection;
+//			}
+//			set {
+//				fieldDirection = value;
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public DirectionExpression(FieldDirection fieldDirection, Expression expression) {
+//			FieldDirection = fieldDirection;
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitDirectionExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[DirectionExpression FieldDirection={0} Expression={1}]", FieldDirection, Expression);
+//		}
+//	}
+//	
+//	public class DoLoopStatement : StatementWithEmbeddedStatement {
+//		
+//		Expression condition;
+//		
+//		ConditionType conditionType;
+//		
+//		ConditionPosition conditionPosition;
+//		
+//		public Expression Condition {
+//			get {
+//				return condition;
+//			}
+//			set {
+//				condition = value ?? Expression.Null;
+//				if (!condition.IsNull) condition.Parent = this;
+//			}
+//		}
+//		
+//		public ConditionType ConditionType {
+//			get {
+//				return conditionType;
+//			}
+//			set {
+//				conditionType = value;
+//			}
+//		}
+//		
+//		public ConditionPosition ConditionPosition {
+//			get {
+//				return conditionPosition;
+//			}
+//			set {
+//				conditionPosition = value;
+//			}
+//		}
+//		
+//		public DoLoopStatement(Expression condition, Statement embeddedStatement, ConditionType conditionType, ConditionPosition conditionPosition) {
+//			Condition = condition;
+//			EmbeddedStatement = embeddedStatement;
+//			ConditionType = conditionType;
+//			ConditionPosition = conditionPosition;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitDoLoopStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[DoLoopStatement Condition={0} ConditionType={1} ConditionPosition={2} EmbeddedSt" +
+//			                     "atement={3}]", Condition, ConditionType, ConditionPosition, EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class ElseIfSection : StatementWithEmbeddedStatement {
+//		
+//		Expression condition;
+//		
+//		public Expression Condition {
+//			get {
+//				return condition;
+//			}
+//			set {
+//				condition = value ?? Expression.Null;
+//				if (!condition.IsNull) condition.Parent = this;
+//			}
+//		}
+//		
+//		public ElseIfSection(Expression condition, Statement embeddedStatement) {
+//			Condition = condition;
+//			EmbeddedStatement = embeddedStatement;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitElseIfSection(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ElseIfSection Condition={0} EmbeddedStatement={1}]", Condition, EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class EndStatement : Statement {
+//		
+//		public EndStatement() {
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitEndStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return "[EndStatement]";
+//		}
+//	}
+//	
+//	public class EraseStatement : Statement {
+//		
+//		List<Expression> expressions;
+//		
+//		public List<Expression> Expressions {
+//			get {
+//				return expressions;
+//			}
+//			set {
+//				expressions = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public EraseStatement() {
+//			expressions = new List<Expression>();
+//		}
+//		
+//		public EraseStatement(List<Expression> expressions) {
+//			Expressions = expressions;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitEraseStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[EraseStatement Expressions={0}]", GetCollectionString(Expressions));
+//		}
+//	}
+//	
+//	public class ErrorStatement : Statement {
+//		
+//		Expression expression;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public ErrorStatement(Expression expression) {
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitErrorStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ErrorStatement Expression={0}]", Expression);
+//		}
+//	}
+//	
+//	public class EventAddRegion : EventAddRemoveRegion {
+//		
+//		public EventAddRegion(List<AttributeSection> attributes) :
+//			base(attributes) {
+//		}
+//		
+//		public static EventAddRegion Null {
+//			get {
+//				return NullEventAddRegion.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitEventAddRegion(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[EventAddRegion Block={0} Parameters={1} Attributes={2} Modifier={3}]", Block, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	internal sealed class NullEventAddRegion : EventAddRegion {
+//		
+//		private NullEventAddRegion() :
+//			base(null) {
+//		}
+//		
+//		internal static NullEventAddRegion Instance = new NullEventAddRegion();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullEventAddRegion]";
+//		}
+//	}
+//	
+//	public abstract class EventAddRemoveRegion : AttributedNode, INullable {
+//		
+//		BlockStatement block;
+//		
+//		List<ParameterDeclarationExpression> parameters;
+//		
+//		public BlockStatement Block {
+//			get {
+//				return block;
+//			}
+//			set {
+//				block = value ?? BlockStatement.Null;
+//				if (!block.IsNull) block.Parent = this;
+//			}
+//		}
+//		
+//		public List<ParameterDeclarationExpression> Parameters {
+//			get {
+//				return parameters;
+//			}
+//			set {
+//				parameters = value ?? new List<ParameterDeclarationExpression>();
+//			}
+//		}
+//		
+//		protected EventAddRemoveRegion(List<AttributeSection> attributes) {
+//			Attributes = attributes;
+//			block = BlockStatement.Null;
+//			parameters = new List<ParameterDeclarationExpression>();
+//		}
+//		
+//		public virtual bool IsNull {
+//			get {
+//				return false;
+//			}
+//		}
+//	}
+//	
+//	public class EventDeclaration : MemberNode {
+//		
+//		EventAddRegion addRegion;
+//		
+//		EventRemoveRegion removeRegion;
+//		
+//		EventRaiseRegion raiseRegion;
+//		
+//		Location bodyStart;
+//		
+//		Location bodyEnd;
+//		
+//		Expression initializer;
+//		
+//		public EventAddRegion AddRegion {
+//			get {
+//				return addRegion;
+//			}
+//			set {
+//				addRegion = value ?? EventAddRegion.Null;
+//				if (!addRegion.IsNull) addRegion.Parent = this;
+//			}
+//		}
+//		
+//		public EventRemoveRegion RemoveRegion {
+//			get {
+//				return removeRegion;
+//			}
+//			set {
+//				removeRegion = value ?? EventRemoveRegion.Null;
+//				if (!removeRegion.IsNull) removeRegion.Parent = this;
+//			}
+//		}
+//		
+//		public EventRaiseRegion RaiseRegion {
+//			get {
+//				return raiseRegion;
+//			}
+//			set {
+//				raiseRegion = value ?? EventRaiseRegion.Null;
+//				if (!raiseRegion.IsNull) raiseRegion.Parent = this;
+//			}
+//		}
+//		
+//		public Location BodyStart {
+//			get {
+//				return bodyStart;
+//			}
+//			set {
+//				bodyStart = value;
+//			}
+//		}
+//		
+//		public Location BodyEnd {
+//			get {
+//				return bodyEnd;
+//			}
+//			set {
+//				bodyEnd = value;
+//			}
+//		}
+//		
+//		public Expression Initializer {
+//			get {
+//				return initializer;
+//			}
+//			set {
+//				initializer = value ?? Expression.Null;
+//				if (!initializer.IsNull) initializer.Parent = this;
+//			}
+//		}
+//		
+//		public EventDeclaration() {
+//			addRegion = EventAddRegion.Null;
+//			removeRegion = EventRemoveRegion.Null;
+//			raiseRegion = EventRaiseRegion.Null;
+//			bodyStart = Location.Empty;
+//			bodyEnd = Location.Empty;
+//			initializer = Expression.Null;
+//		}
+//		
+//		public bool HasAddRegion {
+//			get {
+//				return !addRegion.IsNull;
+//			}
+//		}
+//		
+//		public bool HasRemoveRegion {
+//			get {
+//				return !removeRegion.IsNull;
+//			}
+//		}
+//		
+//		public bool HasRaiseRegion {
+//			get {
+//				return !raiseRegion.IsNull;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitEventDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[EventDeclaration AddRegion={0} RemoveRegion={1} RaiseRegion={2} BodyStart={3} Bo" +
+//			                     "dyEnd={4} Initializer={5} InterfaceImplementations={6} TypeReference={7} Name={8" +
+//			                     "} Parameters={9} Attributes={10} Modifier={11}]", AddRegion, RemoveRegion, RaiseRegion, BodyStart, BodyEnd, Initializer, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class EventRaiseRegion : EventAddRemoveRegion {
+//		
+//		public EventRaiseRegion(List<AttributeSection> attributes) :
+//			base(attributes) {
+//		}
+//		
+//		public static EventRaiseRegion Null {
+//			get {
+//				return NullEventRaiseRegion.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitEventRaiseRegion(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[EventRaiseRegion Block={0} Parameters={1} Attributes={2} Modifier={3}]", Block, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	internal sealed class NullEventRaiseRegion : EventRaiseRegion {
+//		
+//		private NullEventRaiseRegion() :
+//			base(null) {
+//		}
+//		
+//		internal static NullEventRaiseRegion Instance = new NullEventRaiseRegion();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullEventRaiseRegion]";
+//		}
+//	}
+//	
+//	public class EventRemoveRegion : EventAddRemoveRegion {
+//		
+//		public EventRemoveRegion(List<AttributeSection> attributes) :
+//			base(attributes) {
+//		}
+//		
+//		public static EventRemoveRegion Null {
+//			get {
+//				return NullEventRemoveRegion.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitEventRemoveRegion(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[EventRemoveRegion Block={0} Parameters={1} Attributes={2} Modifier={3}]", Block, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	internal sealed class NullEventRemoveRegion : EventRemoveRegion {
+//		
+//		private NullEventRemoveRegion() :
+//			base(null) {
+//		}
+//		
+//		internal static NullEventRemoveRegion Instance = new NullEventRemoveRegion();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullEventRemoveRegion]";
+//		}
+//	}
+//	
+//	public class ExitStatement : Statement {
+//		
+//		ExitType exitType;
+//		
+//		public ExitType ExitType {
+//			get {
+//				return exitType;
+//			}
+//			set {
+//				exitType = value;
+//			}
+//		}
+//		
+//		public ExitStatement(ExitType exitType) {
+//			ExitType = exitType;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitExitStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ExitStatement ExitType={0}]", ExitType);
+//		}
+//	}
+//	
+//	public class ExpressionRangeVariable : AbstractNode, INullable {
+//		
+//		string identifier;
+//		
+//		Expression expression;
+//		
+//		TypeReference type;
+//		
+//		public string Identifier {
+//			get {
+//				return identifier;
+//			}
+//			set {
+//				identifier = value ?? "";
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public TypeReference Type {
+//			get {
+//				return type;
+//			}
+//			set {
+//				type = value ?? TypeReference.Null;
+//				if (!type.IsNull) type.Parent = this;
+//			}
+//		}
+//		
+//		public ExpressionRangeVariable() {
+//			identifier = "";
+//			expression = Expression.Null;
+//			type = TypeReference.Null;
+//		}
+//		
+//		public virtual bool IsNull {
+//			get {
+//				return false;
+//			}
+//		}
+//		
+//		public static ExpressionRangeVariable Null {
+//			get {
+//				return NullExpressionRangeVariable.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitExpressionRangeVariable(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ExpressionRangeVariable Identifier={0} Expression={1} Type={2}]", Identifier, Expression, Type);
+//		}
+//	}
+//	
+//	internal sealed class NullExpressionRangeVariable : ExpressionRangeVariable {
+//		
+//		internal static NullExpressionRangeVariable Instance = new NullExpressionRangeVariable();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullExpressionRangeVariable]";
+//		}
+//	}
+//	
+//	public class ExpressionStatement : Statement {
+//		
+//		Expression expression;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public ExpressionStatement(Expression expression) {
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitExpressionStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ExpressionStatement Expression={0}]", Expression);
+//		}
+//	}
+//	
+//	public class ExternAliasDirective : AbstractNode {
+//		
+//		string name;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public ExternAliasDirective() {
+//			name = "";
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitExternAliasDirective(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ExternAliasDirective Name={0}]", Name);
+//		}
+//	}
+//	
+//	public class FieldDeclaration : AttributedNode {
+//		
+//		TypeReference typeReference;
+//		
+//		List<VariableDeclaration> fields;
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public List<VariableDeclaration> Fields {
+//			get {
+//				return fields;
+//			}
+//			set {
+//				fields = value ?? new List<VariableDeclaration>();
+//			}
+//		}
+//		
+//		public FieldDeclaration(List<AttributeSection> attributes) {
+//			Attributes = attributes;
+//			typeReference = TypeReference.Null;
+//			fields = new List<VariableDeclaration>();
+//		}
+//		
+//		public FieldDeclaration(List<AttributeSection> attributes, TypeReference typeReference, Modifiers modifier) {
+//			Attributes = attributes;
+//			TypeReference = typeReference;
+//			Modifier = modifier;
+//			fields = new List<VariableDeclaration>();
+//		}
+//		
+//
+//		public TypeReference GetTypeForField(int fieldIndex)
+//		{
+//			if (!typeReference.IsNull) {
+//				return typeReference;
+//			}
+//			return ((VariableDeclaration)Fields[fieldIndex]).TypeReference;
+//		}
+//		
+//
+//		public VariableDeclaration GetVariableDeclaration(string variableName)
+//		{
+//			foreach (VariableDeclaration variableDeclaration in Fields) {
+//				if (variableDeclaration.Name == variableName) {
+//					return variableDeclaration;
+//				}
+//			}
+//			return null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitFieldDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[FieldDeclaration TypeReference={0} Fields={1} Attributes={2} Modifier={3}]", TypeReference, GetCollectionString(Fields), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class ForeachStatement : StatementWithEmbeddedStatement {
+//		
+//		TypeReference typeReference;
+//		
+//		string variableName;
+//		
+//		Expression expression;
+//		
+//		Expression nextExpression;
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public string VariableName {
+//			get {
+//				return variableName;
+//			}
+//			set {
+//				variableName = value ?? "";
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public Expression NextExpression {
+//			get {
+//				return nextExpression;
+//			}
+//			set {
+//				nextExpression = value ?? Expression.Null;
+//				if (!nextExpression.IsNull) nextExpression.Parent = this;
+//			}
+//		}
+//		
+//		public ForeachStatement(TypeReference typeReference, string variableName, Expression expression, Statement embeddedStatement) {
+//			TypeReference = typeReference;
+//			VariableName = variableName;
+//			Expression = expression;
+//			EmbeddedStatement = embeddedStatement;
+//			nextExpression = Expression.Null;
+//		}
+//		
+//		public ForeachStatement(TypeReference typeReference, string variableName, Expression expression, Statement embeddedStatement, Expression nextExpression) {
+//			TypeReference = typeReference;
+//			VariableName = variableName;
+//			Expression = expression;
+//			EmbeddedStatement = embeddedStatement;
+//			NextExpression = nextExpression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitForeachStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ForeachStatement TypeReference={0} VariableName={1} Expression={2} NextExpressio" +
+//			                     "n={3} EmbeddedStatement={4}]", TypeReference, VariableName, Expression, NextExpression, EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class ForNextStatement : StatementWithEmbeddedStatement {
+//		
+//		Expression start;
+//		
+//		Expression end;
+//		
+//		Expression step;
+//		
+//		List<Expression> nextExpressions;
+//		
+//		TypeReference typeReference;
+//		
+//		string variableName;
+//		
+//		Expression loopVariableExpression;
+//		
+//		public Expression Start {
+//			get {
+//				return start;
+//			}
+//			set {
+//				start = value ?? Expression.Null;
+//				if (!start.IsNull) start.Parent = this;
+//			}
+//		}
+//		
+//		public Expression End {
+//			get {
+//				return end;
+//			}
+//			set {
+//				end = value ?? Expression.Null;
+//				if (!end.IsNull) end.Parent = this;
+//			}
+//		}
+//		
+//		public Expression Step {
+//			get {
+//				return step;
+//			}
+//			set {
+//				step = value ?? Expression.Null;
+//				if (!step.IsNull) step.Parent = this;
+//			}
+//		}
+//		
+//		public List<Expression> NextExpressions {
+//			get {
+//				return nextExpressions;
+//			}
+//			set {
+//				nextExpressions = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public string VariableName {
+//			get {
+//				return variableName;
+//			}
+//			set {
+//				variableName = value ?? "";
+//			}
+//		}
+//		
+//		public Expression LoopVariableExpression {
+//			get {
+//				return loopVariableExpression;
+//			}
+//			set {
+//				loopVariableExpression = value ?? Expression.Null;
+//				if (!loopVariableExpression.IsNull) loopVariableExpression.Parent = this;
+//			}
+//		}
+//		
+//		public ForNextStatement() {
+//			start = Expression.Null;
+//			end = Expression.Null;
+//			step = Expression.Null;
+//			nextExpressions = new List<Expression>();
+//			typeReference = TypeReference.Null;
+//			variableName = "";
+//			loopVariableExpression = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitForNextStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ForNextStatement Start={0} End={1} Step={2} NextExpressions={3} TypeReference={4" +
+//			                     "} VariableName={5} LoopVariableExpression={6} EmbeddedStatement={7}]", Start, End, Step, GetCollectionString(NextExpressions), TypeReference, VariableName, LoopVariableExpression, EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class GotoStatement : Statement {
+//		
+//		string label;
+//		
+//		public string Label {
+//			get {
+//				return label;
+//			}
+//			set {
+//				label = value ?? "";
+//			}
+//		}
+//		
+//		public GotoStatement(string label) {
+//			Label = label;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitGotoStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[GotoStatement Label={0}]", Label);
+//		}
+//	}
+//	
+//	public class IfElseStatement : Statement {
+//		
+//		Expression condition;
+//		
+//		List<Statement> trueStatement;
+//		
+//		List<Statement> falseStatement;
+//		
+//		List<ElseIfSection> elseIfSections;
+//		
+//		public Expression Condition {
+//			get {
+//				return condition;
+//			}
+//			set {
+//				condition = value ?? Expression.Null;
+//				if (!condition.IsNull) condition.Parent = this;
+//			}
+//		}
+//		
+//		public List<Statement> TrueStatement {
+//			get {
+//				return trueStatement;
+//			}
+//			set {
+//				trueStatement = value ?? new List<Statement>();
+//			}
+//		}
+//		
+//		public List<Statement> FalseStatement {
+//			get {
+//				return falseStatement;
+//			}
+//			set {
+//				falseStatement = value ?? new List<Statement>();
+//			}
+//		}
+//		
+//		public List<ElseIfSection> ElseIfSections {
+//			get {
+//				return elseIfSections;
+//			}
+//			set {
+//				elseIfSections = value ?? new List<ElseIfSection>();
+//			}
+//		}
+//		
+//		public IfElseStatement(Expression condition) {
+//			Condition = condition;
+//			trueStatement = new List<Statement>();
+//			falseStatement = new List<Statement>();
+//			elseIfSections = new List<ElseIfSection>();
+//		}
+//		
+//
+//		public IfElseStatement(Expression condition, Statement trueStatement)
+//			: this(condition) {
+//			this.trueStatement.Add(Statement.CheckNull(trueStatement));
+//			if (trueStatement != null) trueStatement.Parent = this;
+//		}
+//		
+//		public bool HasElseStatements {
+//			get {
+//				return falseStatement.Count > 0;
+//			}
+//		}
+//		
+//		public bool HasElseIfSections {
+//			get {
+//				return elseIfSections.Count > 0;
+//			}
+//		}
+//		
+//
+//		public IfElseStatement(Expression condition, Statement trueStatement, Statement falseStatement)
+//			: this(condition) {
+//			this.trueStatement.Add(Statement.CheckNull(trueStatement));
+//			this.falseStatement.Add(Statement.CheckNull(falseStatement));
+//			if (trueStatement != null) trueStatement.Parent = this;
+//			if (falseStatement != null) falseStatement.Parent = this;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitIfElseStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[IfElseStatement Condition={0} TrueStatement={1} FalseStatement={2} ElseIfSection" +
+//			                     "s={3}]", Condition, GetCollectionString(TrueStatement), GetCollectionString(FalseStatement), GetCollectionString(ElseIfSections));
+//		}
+//	}
+//	
+//	public class InterfaceImplementation : AbstractNode {
+//		
+//		TypeReference interfaceType;
+//		
+//		string memberName;
+//		
+//		public TypeReference InterfaceType {
+//			get {
+//				return interfaceType;
+//			}
+//			set {
+//				interfaceType = value ?? TypeReference.Null;
+//				if (!interfaceType.IsNull) interfaceType.Parent = this;
+//			}
+//		}
+//		
+//		public string MemberName {
+//			get {
+//				return memberName;
+//			}
+//			set {
+//				memberName = string.IsNullOrEmpty(value) ? "?" : value;
+//			}
+//		}
+//		
+//		public InterfaceImplementation(TypeReference interfaceType, string memberName) {
+//			InterfaceType = interfaceType;
+//			MemberName = memberName;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitInterfaceImplementation(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[InterfaceImplementation InterfaceType={0} MemberName={1}]", InterfaceType, MemberName);
+//		}
+//	}
+//	
+//	public class InvocationExpression : Expression {
+//		
+//		Expression targetObject;
+//		
+//		List<Expression> arguments;
+//		
+//		public Expression TargetObject {
+//			get {
+//				return targetObject;
+//			}
+//			set {
+//				targetObject = value ?? Expression.Null;
+//				if (!targetObject.IsNull) targetObject.Parent = this;
+//			}
+//		}
+//		
+//		public List<Expression> Arguments {
+//			get {
+//				return arguments;
+//			}
+//			set {
+//				arguments = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public InvocationExpression(Expression targetObject) {
+//			TargetObject = targetObject;
+//			arguments = new List<Expression>();
+//		}
+//		
+//		public InvocationExpression(Expression targetObject, List<Expression> arguments) {
+//			TargetObject = targetObject;
+//			Arguments = arguments;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitInvocationExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[InvocationExpression TargetObject={0} Arguments={1}]", TargetObject, GetCollectionString(Arguments));
+//		}
+//	}
+//	
+//	public class LabelStatement : Statement {
+//		
+//		string label;
+//		
+//		public string Label {
+//			get {
+//				return label;
+//			}
+//			set {
+//				label = value ?? "";
+//			}
+//		}
+//		
+//		public LabelStatement(string label) {
+//			Label = label;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitLabelStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[LabelStatement Label={0}]", Label);
+//		}
+//	}
+//	
+//	public class LambdaExpression : Expression {
+//		
+//		List<ParameterDeclarationExpression> parameters;
+//		
+//		Statement statementBody;
+//		
+//		Expression expressionBody;
+//		
+//		TypeReference returnType;
+//		
+//		public List<ParameterDeclarationExpression> Parameters {
+//			get {
+//				return parameters;
+//			}
+//			set {
+//				parameters = value ?? new List<ParameterDeclarationExpression>();
+//			}
+//		}
+//		
+//		public Statement StatementBody {
+//			get {
+//				return statementBody;
+//			}
+//			set {
+//				statementBody = value ?? Statement.Null;
+//				if (!statementBody.IsNull) statementBody.Parent = this;
+//			}
+//		}
+//		
+//		public Expression ExpressionBody {
+//			get {
+//				return expressionBody;
+//			}
+//			set {
+//				expressionBody = value ?? Expression.Null;
+//				if (!expressionBody.IsNull) expressionBody.Parent = this;
+//			}
+//		}
+//		
+//		public TypeReference ReturnType {
+//			get {
+//				return returnType;
+//			}
+//			set {
+//				returnType = value ?? TypeReference.Null;
+//				if (!returnType.IsNull) returnType.Parent = this;
+//			}
+//		}
+//		
+//		public LambdaExpression() {
+//			parameters = new List<ParameterDeclarationExpression>();
+//			statementBody = Statement.Null;
+//			expressionBody = Expression.Null;
+//			returnType = TypeReference.Null;
+//		}
+//		
+//		public Location ExtendedEndLocation { get; set; }
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitLambdaExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[LambdaExpression Parameters={0} StatementBody={1} ExpressionBody={2} ReturnType=" +
+//			                     "{3}]", GetCollectionString(Parameters), StatementBody, ExpressionBody, ReturnType);
+//		}
+//	}
+//	
+//	public class LockStatement : StatementWithEmbeddedStatement {
+//		
+//		Expression lockExpression;
+//		
+//		public Expression LockExpression {
+//			get {
+//				return lockExpression;
+//			}
+//			set {
+//				lockExpression = value ?? Expression.Null;
+//				if (!lockExpression.IsNull) lockExpression.Parent = this;
+//			}
+//		}
+//		
+//		public LockStatement(Expression lockExpression, Statement embeddedStatement) {
+//			LockExpression = lockExpression;
+//			EmbeddedStatement = embeddedStatement;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitLockStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[LockStatement LockExpression={0} EmbeddedStatement={1}]", LockExpression, EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class MemberInitializerExpression : Expression {
+//		
+//		string name;
+//		
+//		bool isKey;
+//		
+//		Expression expression;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public bool IsKey {
+//			get {
+//				return isKey;
+//			}
+//			set {
+//				isKey = value;
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public MemberInitializerExpression() {
+//			name = "";
+//			expression = Expression.Null;
+//		}
+//		
+//		public MemberInitializerExpression(string name, Expression expression) {
+//			Name = name;
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitMemberInitializerExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[MemberInitializerExpression Name={0} IsKey={1} Expression={2}]", Name, IsKey, Expression);
+//		}
+//	}
+//	
+//	public abstract class MemberNode : ParametrizedNode {
+//		
+//		List<InterfaceImplementation> interfaceImplementations;
+//		
+//		TypeReference typeReference;
+//		
+//		public List<InterfaceImplementation> InterfaceImplementations {
+//			get {
+//				return interfaceImplementations;
+//			}
+//			set {
+//				interfaceImplementations = value ?? new List<InterfaceImplementation>();
+//			}
+//		}
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		protected MemberNode() {
+//			interfaceImplementations = new List<InterfaceImplementation>();
+//			typeReference = TypeReference.Null;
+//		}
+//		
+//		protected MemberNode(Modifiers modifier, List<AttributeSection> attributes, string name, List<ParameterDeclarationExpression> parameters) {
+//			Modifier = modifier;
+//			Attributes = attributes;
+//			Name = name;
+//			Parameters = parameters;
+//			interfaceImplementations = new List<InterfaceImplementation>();
+//			typeReference = TypeReference.Null;
+//		}
+//	}
+//	
+//	public class MemberReferenceExpression : Expression {
+//		
+//		Expression targetObject;
+//		
+//		string memberName;
+//		
+//		List<TypeReference> typeArguments;
+//		
+//		public Expression TargetObject {
+//			get {
+//				return targetObject;
+//			}
+//			set {
+//				targetObject = value ?? Expression.Null;
+//				if (!targetObject.IsNull) targetObject.Parent = this;
+//			}
+//		}
+//		
+//		public string MemberName {
+//			get {
+//				return memberName;
+//			}
+//			set {
+//				memberName = value ?? "";
+//			}
+//		}
+//		
+//		public List<TypeReference> TypeArguments {
+//			get {
+//				return typeArguments;
+//			}
+//			set {
+//				typeArguments = value ?? new List<TypeReference>();
+//			}
+//		}
+//		
+//		public MemberReferenceExpression(Expression targetObject, string memberName) {
+//			TargetObject = targetObject;
+//			MemberName = memberName;
+//			typeArguments = new List<TypeReference>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitMemberReferenceExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[MemberReferenceExpression TargetObject={0} MemberName={1} TypeArguments={2}]", TargetObject, MemberName, GetCollectionString(TypeArguments));
+//		}
+//	}
+//	
+//	public class MethodDeclaration : MemberNode {
+//		
+//		BlockStatement body;
+//		
+//		List<string> handlesClause;
+//		
+//		List<TemplateDefinition> templates;
+//		
+//		bool isExtensionMethod;
+//		
+//		public BlockStatement Body {
+//			get {
+//				return body;
+//			}
+//			set {
+//				body = value ?? BlockStatement.Null;
+//				if (!body.IsNull) body.Parent = this;
+//			}
+//		}
+//		
+//		public List<string> HandlesClause {
+//			get {
+//				return handlesClause;
+//			}
+//			set {
+//				handlesClause = value ?? new List<String>();
+//			}
+//		}
+//		
+//		public List<TemplateDefinition> Templates {
+//			get {
+//				return templates;
+//			}
+//			set {
+//				templates = value ?? new List<TemplateDefinition>();
+//			}
+//		}
+//		
+//		public bool IsExtensionMethod {
+//			get {
+//				return isExtensionMethod;
+//			}
+//			set {
+//				isExtensionMethod = value;
+//			}
+//		}
+//		
+//		public MethodDeclaration() {
+//			body = BlockStatement.Null;
+//			handlesClause = new List<String>();
+//			templates = new List<TemplateDefinition>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitMethodDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[MethodDeclaration Body={0} HandlesClause={1} Templates={2} IsExtensionMethod={3}" +
+//			                     " InterfaceImplementations={4} TypeReference={5} Name={6} Parameters={7} Attribut" +
+//			                     "es={8} Modifier={9}]", Body, GetCollectionString(HandlesClause), GetCollectionString(Templates), IsExtensionMethod, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class NamedArgumentExpression : Expression {
+//		
+//		string name;
+//		
+//		Expression expression;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public NamedArgumentExpression() {
+//			name = "";
+//			expression = Expression.Null;
+//		}
+//		
+//		public NamedArgumentExpression(string name, Expression expression) {
+//			Name = name;
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitNamedArgumentExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[NamedArgumentExpression Name={0} Expression={1}]", Name, Expression);
+//		}
+//	}
+//	
+//	public class NamespaceDeclaration : AbstractNode {
+//		
+//		string name;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public NamespaceDeclaration(string name) {
+//			Name = name;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitNamespaceDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[NamespaceDeclaration Name={0}]", Name);
+//		}
+//	}
+//	
+//	public class ObjectCreateExpression : Expression {
+//		
+//		TypeReference createType;
+//		
+//		List<Expression> parameters;
+//		
+//		CollectionInitializerExpression objectInitializer;
+//		
+//		public TypeReference CreateType {
+//			get {
+//				return createType;
+//			}
+//			set {
+//				createType = value ?? TypeReference.Null;
+//				if (!createType.IsNull) createType.Parent = this;
+//			}
+//		}
+//		
+//		public List<Expression> Parameters {
+//			get {
+//				return parameters;
+//			}
+//			set {
+//				parameters = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public CollectionInitializerExpression ObjectInitializer {
+//			get {
+//				return objectInitializer;
+//			}
+//			set {
+//				objectInitializer = value ?? CollectionInitializerExpression.Null;
+//				if (!objectInitializer.IsNull) objectInitializer.Parent = this;
+//			}
+//		}
+//		
+//		public ObjectCreateExpression(TypeReference createType, List<Expression> parameters) {
+//			CreateType = createType;
+//			Parameters = parameters;
+//			objectInitializer = CollectionInitializerExpression.Null;
+//		}
+//		
+//		public bool IsAnonymousType {
+//			get {
+//				return createType.IsNull || string.IsNullOrEmpty(createType.Type);
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitObjectCreateExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ObjectCreateExpression CreateType={0} Parameters={1} ObjectInitializer={2}]", CreateType, GetCollectionString(Parameters), ObjectInitializer);
+//		}
+//	}
+//	
+//	public class OnErrorStatement : StatementWithEmbeddedStatement {
+//		
+//		public OnErrorStatement(Statement embeddedStatement) {
+//			EmbeddedStatement = embeddedStatement;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitOnErrorStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[OnErrorStatement EmbeddedStatement={0}]", EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class OperatorDeclaration : MethodDeclaration {
+//		
+//		ConversionType conversionType;
+//		
+//		OverloadableOperatorType overloadableOperator;
+//		
+//		public ConversionType ConversionType {
+//			get {
+//				return conversionType;
+//			}
+//			set {
+//				conversionType = value;
+//			}
+//		}
+//		
+//		public OverloadableOperatorType OverloadableOperator {
+//			get {
+//				return overloadableOperator;
+//			}
+//			set {
+//				overloadableOperator = value;
+//			}
+//		}
+//		
+//		public OperatorDeclaration() {
+//		}
+//		
+//		public bool IsConversionOperator {
+//			get {
+//				return conversionType != ConversionType.None;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitOperatorDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[OperatorDeclaration ConversionType={0} OverloadableOperator={1} Body={2} Handles" +
+//			                     "Clause={3} Templates={4} IsExtensionMethod={5} InterfaceImplementations={6} Type" +
+//			                     "Reference={7} Name={8} Parameters={9} Attributes={10} Modifier={11}]", ConversionType, OverloadableOperator, Body, GetCollectionString(HandlesClause), GetCollectionString(Templates), IsExtensionMethod, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class ParameterDeclarationExpression : Expression {
+//		
+//		List<AttributeSection> attributes;
+//		
+//		string parameterName;
+//		
+//		TypeReference typeReference;
+//		
+//		ParameterModifiers paramModifier;
+//		
+//		Expression defaultValue;
+//		
+//		public List<AttributeSection> Attributes {
+//			get {
+//				return attributes;
+//			}
+//			set {
+//				attributes = value ?? new List<AttributeSection>();
+//			}
+//		}
+//		
+//		public string ParameterName {
+//			get {
+//				return parameterName;
+//			}
+//			set {
+//				parameterName = string.IsNullOrEmpty(value) ? "?" : value;
+//			}
+//		}
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public ParameterModifiers ParamModifier {
+//			get {
+//				return paramModifier;
+//			}
+//			set {
+//				paramModifier = value;
+//			}
+//		}
+//		
+//		public Expression DefaultValue {
+//			get {
+//				return defaultValue;
+//			}
+//			set {
+//				defaultValue = value ?? Expression.Null;
+//				if (!defaultValue.IsNull) defaultValue.Parent = this;
+//			}
+//		}
+//		
+//		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName) {
+//			TypeReference = typeReference;
+//			ParameterName = parameterName;
+//			attributes = new List<AttributeSection>();
+//			defaultValue = Expression.Null;
+//		}
+//		
+//		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParameterModifiers paramModifier) {
+//			TypeReference = typeReference;
+//			ParameterName = parameterName;
+//			ParamModifier = paramModifier;
+//			attributes = new List<AttributeSection>();
+//			defaultValue = Expression.Null;
+//		}
+//		
+//		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParameterModifiers paramModifier, Expression defaultValue) {
+//			TypeReference = typeReference;
+//			ParameterName = parameterName;
+//			ParamModifier = paramModifier;
+//			DefaultValue = defaultValue;
+//			attributes = new List<AttributeSection>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitParameterDeclarationExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ParameterDeclarationExpression Attributes={0} ParameterName={1} TypeReference={2" +
+//			                     "} ParamModifier={3} DefaultValue={4}]", GetCollectionString(Attributes), ParameterName, TypeReference, ParamModifier, DefaultValue);
+//		}
+//	}
+//	
+//	public abstract class ParametrizedNode : AttributedNode {
+//		
+//		string name;
+//		
+//		List<ParameterDeclarationExpression> parameters;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public List<ParameterDeclarationExpression> Parameters {
+//			get {
+//				return parameters;
+//			}
+//			set {
+//				parameters = value ?? new List<ParameterDeclarationExpression>();
+//			}
+//		}
+//		
+//		protected ParametrizedNode() {
+//			name = "";
+//			parameters = new List<ParameterDeclarationExpression>();
+//		}
+//		
+//		protected ParametrizedNode(Modifiers modifier, List<AttributeSection> attributes, string name, List<ParameterDeclarationExpression> parameters) {
+//			Modifier = modifier;
+//			Attributes = attributes;
+//			Name = name;
+//			Parameters = parameters;
+//		}
+//	}
+//	
+//	public class ParenthesizedExpression : Expression {
+//		
+//		Expression expression;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public ParenthesizedExpression(Expression expression) {
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitParenthesizedExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ParenthesizedExpression Expression={0}]", Expression);
+//		}
+//	}
+//	
+//	public class PropertyDeclaration : MemberNode {
+//		
+//		Location bodyStart;
+//		
+//		Location bodyEnd;
+//		
+//		PropertyGetRegion getRegion;
+//		
+//		PropertySetRegion setRegion;
+//		
+//		Expression initializer;
+//		
+//		public Location BodyStart {
+//			get {
+//				return bodyStart;
+//			}
+//			set {
+//				bodyStart = value;
+//			}
+//		}
+//		
+//		public Location BodyEnd {
+//			get {
+//				return bodyEnd;
+//			}
+//			set {
+//				bodyEnd = value;
+//			}
+//		}
+//		
+//		public PropertyGetRegion GetRegion {
+//			get {
+//				return getRegion;
+//			}
+//			set {
+//				getRegion = value ?? PropertyGetRegion.Null;
+//				if (!getRegion.IsNull) getRegion.Parent = this;
+//			}
+//		}
+//		
+//		public PropertySetRegion SetRegion {
+//			get {
+//				return setRegion;
+//			}
+//			set {
+//				setRegion = value ?? PropertySetRegion.Null;
+//				if (!setRegion.IsNull) setRegion.Parent = this;
+//			}
+//		}
+//		
+//		public Expression Initializer {
+//			get {
+//				return initializer;
+//			}
+//			set {
+//				initializer = value ?? Expression.Null;
+//				if (!initializer.IsNull) initializer.Parent = this;
+//			}
+//		}
+//		
+//		public PropertyDeclaration(Modifiers modifier, List<AttributeSection> attributes, string name, List<ParameterDeclarationExpression> parameters) {
+//			Modifier = modifier;
+//			Attributes = attributes;
+//			Name = name;
+//			Parameters = parameters;
+//			bodyStart = Location.Empty;
+//			bodyEnd = Location.Empty;
+//			getRegion = PropertyGetRegion.Null;
+//			setRegion = PropertySetRegion.Null;
+//			initializer = Expression.Null;
+//		}
+//		
+//		public bool IsReadOnly {
+//			get {
+//				return HasGetRegion && !HasSetRegion;
+//			}
+//		}
+//		
+//		public bool HasGetRegion {
+//			get {
+//				return !getRegion.IsNull;
+//			}
+//		}
+//		
+//		public bool IsWriteOnly {
+//			get {
+//				return !HasGetRegion && HasSetRegion;
+//			}
+//		}
+//		
+//		public bool IsIndexer {
+//			get {
+//				return (Modifier & Modifiers.Default) != 0;
+//			}
+//		}
+//		
+//
+//		internal PropertyDeclaration(string name, TypeReference typeReference, Modifiers modifier, List<AttributeSection> attributes) : this(modifier, attributes, name, null)
+//		{
+//			this.TypeReference = typeReference;
+//			if ((modifier & Modifiers.ReadOnly) != Modifiers.ReadOnly) {
+//				this.SetRegion = new PropertySetRegion(null, null);
+//			}
+//			if ((modifier & Modifiers.WriteOnly) != Modifiers.WriteOnly) {
+//				this.GetRegion = new PropertyGetRegion(null, null);
+//			}
+//		}
+//		
+//		public bool HasSetRegion {
+//			get {
+//				return !setRegion.IsNull;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitPropertyDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[PropertyDeclaration BodyStart={0} BodyEnd={1} GetRegion={2} SetRegion={3} Initia" +
+//			                     "lizer={4} InterfaceImplementations={5} TypeReference={6} Name={7} Parameters={8}" +
+//			                     " Attributes={9} Modifier={10}]", BodyStart, BodyEnd, GetRegion, SetRegion, Initializer, GetCollectionString(InterfaceImplementations), TypeReference, Name, GetCollectionString(Parameters), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class PropertyGetRegion : PropertyGetSetRegion {
+//		
+//		public PropertyGetRegion(BlockStatement block, List<AttributeSection> attributes) :
+//			base(block, attributes) {
+//		}
+//		
+//		public static PropertyGetRegion Null {
+//			get {
+//				return NullPropertyGetRegion.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitPropertyGetRegion(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[PropertyGetRegion Block={0} Attributes={1} Modifier={2}]", Block, GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	internal sealed class NullPropertyGetRegion : PropertyGetRegion {
+//		
+//		private NullPropertyGetRegion() :
+//			base(null, null) {
+//		}
+//		
+//		internal static NullPropertyGetRegion Instance = new NullPropertyGetRegion();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullPropertyGetRegion]";
+//		}
+//	}
+//	
+//	public abstract class PropertyGetSetRegion : AttributedNode, INullable {
+//		
+//		BlockStatement block;
+//		
+//		public BlockStatement Block {
+//			get {
+//				return block;
+//			}
+//			set {
+//				block = value ?? BlockStatement.Null;
+//				if (!block.IsNull) block.Parent = this;
+//			}
+//		}
+//		
+//		protected PropertyGetSetRegion(BlockStatement block, List<AttributeSection> attributes) {
+//			Block = block;
+//			Attributes = attributes;
+//		}
+//		
+//		public virtual bool IsNull {
+//			get {
+//				return false;
+//			}
+//		}
+//	}
+//	
+//	public class PropertySetRegion : PropertyGetSetRegion {
+//		
+//		List<ParameterDeclarationExpression> parameters;
+//		
+//		public List<ParameterDeclarationExpression> Parameters {
+//			get {
+//				return parameters;
+//			}
+//			set {
+//				parameters = value ?? new List<ParameterDeclarationExpression>();
+//			}
+//		}
+//		
+//		public PropertySetRegion(BlockStatement block, List<AttributeSection> attributes) :
+//			base(block, attributes) {
+//			parameters = new List<ParameterDeclarationExpression>();
+//		}
+//		
+//		public static PropertySetRegion Null {
+//			get {
+//				return NullPropertySetRegion.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitPropertySetRegion(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[PropertySetRegion Parameters={0} Block={1} Attributes={2} Modifier={3}]", GetCollectionString(Parameters), Block, GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	internal sealed class NullPropertySetRegion : PropertySetRegion {
+//		
+//		private NullPropertySetRegion() :
+//			base(null, null) {
+//		}
+//		
+//		internal static NullPropertySetRegion Instance = new NullPropertySetRegion();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullPropertySetRegion]";
+//		}
+//	}
+//	
+//	public class QueryExpression : Expression {
+//		
+//		List<QueryExpressionClause> clauses;
+//		
+//		public List<QueryExpressionClause> Clauses {
+//			get {
+//				return clauses;
+//			}
+//			set {
+//				clauses = value ?? new List<QueryExpressionClause>();
+//			}
+//		}
+//		
+//		public QueryExpression() {
+//			clauses = new List<QueryExpressionClause>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpression Clauses={0}]", GetCollectionString(Clauses));
+//		}
+//	}
+//	
+//	public class QueryExpressionAggregateClause : QueryExpressionClause {
+//		
+//		CollectionRangeVariable source;
+//		
+//		List<QueryExpressionClause> middleClauses;
+//		
+//		List<ExpressionRangeVariable> intoVariables;
+//		
+//		public CollectionRangeVariable Source {
+//			get {
+//				return source;
+//			}
+//			set {
+//				source = value ?? CollectionRangeVariable.Null;
+//				if (!source.IsNull) source.Parent = this;
+//			}
+//		}
+//		
+//		public List<QueryExpressionClause> MiddleClauses {
+//			get {
+//				return middleClauses;
+//			}
+//			set {
+//				middleClauses = value ?? new List<QueryExpressionClause>();
+//			}
+//		}
+//		
+//		public List<ExpressionRangeVariable> IntoVariables {
+//			get {
+//				return intoVariables;
+//			}
+//			set {
+//				intoVariables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public QueryExpressionAggregateClause() {
+//			source = CollectionRangeVariable.Null;
+//			middleClauses = new List<QueryExpressionClause>();
+//			intoVariables = new List<ExpressionRangeVariable>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionAggregateClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionAggregateClause Source={0} MiddleClauses={1} IntoVariables={2}]", Source, GetCollectionString(MiddleClauses), GetCollectionString(IntoVariables));
+//		}
+//	}
+//	
+//	public abstract class QueryExpressionClause : AbstractNode, INullable {
+//		
+//		protected QueryExpressionClause() {
+//		}
+//		
+//		public virtual bool IsNull {
+//			get {
+//				return false;
+//			}
+//		}
+//		
+//		public static QueryExpressionClause Null {
+//			get {
+//				return NullQueryExpressionClause.Instance;
+//			}
+//		}
+//	}
+//	
+//	internal sealed class NullQueryExpressionClause : QueryExpressionClause {
+//		
+//		internal static NullQueryExpressionClause Instance = new NullQueryExpressionClause();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullQueryExpressionClause]";
+//		}
+//	}
+//	
+//	public class QueryExpressionDistinctClause : QueryExpressionClause {
+//		
+//		public QueryExpressionDistinctClause() {
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionDistinctClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return "[QueryExpressionDistinctClause]";
+//		}
+//	}
+//	
+//	public class QueryExpressionFromClause : QueryExpressionClause {
+//		
+//		List<CollectionRangeVariable> sources;
+//		
+//		public List<CollectionRangeVariable> Sources {
+//			get {
+//				return sources;
+//			}
+//			set {
+//				sources = value ?? new List<CollectionRangeVariable>();
+//			}
+//		}
+//		
+//		public QueryExpressionFromClause() {
+//			sources = new List<CollectionRangeVariable>();
+//		}
+//		
+//		public new static QueryExpressionFromClause Null {
+//			get {
+//				return NullQueryExpressionFromClause.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionFromClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionFromClause Sources={0}]", GetCollectionString(Sources));
+//		}
+//	}
+//	
+//	internal sealed class NullQueryExpressionFromClause : QueryExpressionFromClause {
+//		
+//		internal static NullQueryExpressionFromClause Instance = new NullQueryExpressionFromClause();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullQueryExpressionFromClause]";
+//		}
+//	}
+//	
+//	public class QueryExpressionGroupClause : QueryExpressionClause {
+//		
+//		Expression projection;
+//		
+//		Expression groupBy;
+//		
+//		public Expression Projection {
+//			get {
+//				return projection;
+//			}
+//			set {
+//				projection = value ?? Expression.Null;
+//				if (!projection.IsNull) projection.Parent = this;
+//			}
+//		}
+//		
+//		public Expression GroupBy {
+//			get {
+//				return groupBy;
+//			}
+//			set {
+//				groupBy = value ?? Expression.Null;
+//				if (!groupBy.IsNull) groupBy.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionGroupClause() {
+//			projection = Expression.Null;
+//			groupBy = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionGroupClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionGroupClause Projection={0} GroupBy={1}]", Projection, GroupBy);
+//		}
+//	}
+//	
+//	public class QueryExpressionGroupJoinVBClause : QueryExpressionClause {
+//		
+//		QueryExpressionJoinVBClause joinClause;
+//		
+//		List<ExpressionRangeVariable> intoVariables;
+//		
+//		public QueryExpressionJoinVBClause JoinClause {
+//			get {
+//				return joinClause;
+//			}
+//			set {
+//				joinClause = value ?? QueryExpressionJoinVBClause.Null;
+//				if (!joinClause.IsNull) joinClause.Parent = this;
+//			}
+//		}
+//		
+//		public List<ExpressionRangeVariable> IntoVariables {
+//			get {
+//				return intoVariables;
+//			}
+//			set {
+//				intoVariables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public QueryExpressionGroupJoinVBClause() {
+//			joinClause = QueryExpressionJoinVBClause.Null;
+//			intoVariables = new List<ExpressionRangeVariable>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionGroupJoinVBClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionGroupJoinVBClause JoinClause={0} IntoVariables={1}]", JoinClause, GetCollectionString(IntoVariables));
+//		}
+//	}
+//	
+//	public class QueryExpressionGroupVBClause : QueryExpressionClause {
+//		
+//		List<ExpressionRangeVariable> groupVariables;
+//		
+//		List<ExpressionRangeVariable> byVariables;
+//		
+//		List<ExpressionRangeVariable> intoVariables;
+//		
+//		public List<ExpressionRangeVariable> GroupVariables {
+//			get {
+//				return groupVariables;
+//			}
+//			set {
+//				groupVariables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public List<ExpressionRangeVariable> ByVariables {
+//			get {
+//				return byVariables;
+//			}
+//			set {
+//				byVariables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public List<ExpressionRangeVariable> IntoVariables {
+//			get {
+//				return intoVariables;
+//			}
+//			set {
+//				intoVariables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public QueryExpressionGroupVBClause() {
+//			groupVariables = new List<ExpressionRangeVariable>();
+//			byVariables = new List<ExpressionRangeVariable>();
+//			intoVariables = new List<ExpressionRangeVariable>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionGroupVBClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionGroupVBClause GroupVariables={0} ByVariables={1} IntoVariables={2" +
+//			                     "}]", GetCollectionString(GroupVariables), GetCollectionString(ByVariables), GetCollectionString(IntoVariables));
+//		}
+//	}
+//	
+//	public class QueryExpressionJoinClause : QueryExpressionClause {
+//		
+//		Expression onExpression;
+//		
+//		Expression equalsExpression;
+//		
+//		CollectionRangeVariable source;
+//		
+//		string intoIdentifier;
+//		
+//		public Expression OnExpression {
+//			get {
+//				return onExpression;
+//			}
+//			set {
+//				onExpression = value ?? Expression.Null;
+//				if (!onExpression.IsNull) onExpression.Parent = this;
+//			}
+//		}
+//		
+//		public Expression EqualsExpression {
+//			get {
+//				return equalsExpression;
+//			}
+//			set {
+//				equalsExpression = value ?? Expression.Null;
+//				if (!equalsExpression.IsNull) equalsExpression.Parent = this;
+//			}
+//		}
+//		
+//		public CollectionRangeVariable Source {
+//			get {
+//				return source;
+//			}
+//			set {
+//				source = value ?? CollectionRangeVariable.Null;
+//				if (!source.IsNull) source.Parent = this;
+//			}
+//		}
+//		
+//		public string IntoIdentifier {
+//			get {
+//				return intoIdentifier;
+//			}
+//			set {
+//				intoIdentifier = value ?? "";
+//			}
+//		}
+//		
+//		public QueryExpressionJoinClause() {
+//			onExpression = Expression.Null;
+//			equalsExpression = Expression.Null;
+//			source = CollectionRangeVariable.Null;
+//			intoIdentifier = "";
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionJoinClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionJoinClause OnExpression={0} EqualsExpression={1} Source={2} IntoI" +
+//			                     "dentifier={3}]", OnExpression, EqualsExpression, Source, IntoIdentifier);
+//		}
+//	}
+//	
+//	public class QueryExpressionJoinConditionVB : AbstractNode {
+//		
+//		Expression leftSide;
+//		
+//		Expression rightSide;
+//		
+//		public Expression LeftSide {
+//			get {
+//				return leftSide;
+//			}
+//			set {
+//				leftSide = value ?? Expression.Null;
+//				if (!leftSide.IsNull) leftSide.Parent = this;
+//			}
+//		}
+//		
+//		public Expression RightSide {
+//			get {
+//				return rightSide;
+//			}
+//			set {
+//				rightSide = value ?? Expression.Null;
+//				if (!rightSide.IsNull) rightSide.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionJoinConditionVB() {
+//			leftSide = Expression.Null;
+//			rightSide = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionJoinConditionVB(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionJoinConditionVB LeftSide={0} RightSide={1}]", LeftSide, RightSide);
+//		}
+//	}
+//	
+//	public class QueryExpressionJoinVBClause : QueryExpressionClause {
+//		
+//		CollectionRangeVariable joinVariable;
+//		
+//		QueryExpressionJoinVBClause subJoin;
+//		
+//		List<QueryExpressionJoinConditionVB> conditions;
+//		
+//		public CollectionRangeVariable JoinVariable {
+//			get {
+//				return joinVariable;
+//			}
+//			set {
+//				joinVariable = value ?? CollectionRangeVariable.Null;
+//				if (!joinVariable.IsNull) joinVariable.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionJoinVBClause SubJoin {
+//			get {
+//				return subJoin;
+//			}
+//			set {
+//				subJoin = value ?? QueryExpressionJoinVBClause.Null;
+//				if (!subJoin.IsNull) subJoin.Parent = this;
+//			}
+//		}
+//		
+//		public List<QueryExpressionJoinConditionVB> Conditions {
+//			get {
+//				return conditions;
+//			}
+//			set {
+//				conditions = value ?? new List<QueryExpressionJoinConditionVB>();
+//			}
+//		}
+//		
+//		public QueryExpressionJoinVBClause() {
+//			joinVariable = CollectionRangeVariable.Null;
+//			subJoin = QueryExpressionJoinVBClause.Null;
+//			conditions = new List<QueryExpressionJoinConditionVB>();
+//		}
+//		
+//		public new static QueryExpressionJoinVBClause Null {
+//			get {
+//				return NullQueryExpressionJoinVBClause.Instance;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionJoinVBClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionJoinVBClause JoinVariable={0} SubJoin={1} Conditions={2}]", JoinVariable, SubJoin, GetCollectionString(Conditions));
+//		}
+//	}
+//	
+//	internal sealed class NullQueryExpressionJoinVBClause : QueryExpressionJoinVBClause {
+//		
+//		internal static NullQueryExpressionJoinVBClause Instance = new NullQueryExpressionJoinVBClause();
+//		
+//		public override bool IsNull {
+//			get {
+//				return true;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return null;
+//		}
+//		
+//		public override string ToString() {
+//			return "[NullQueryExpressionJoinVBClause]";
+//		}
+//	}
+//	
+//	public class QueryExpressionLetClause : QueryExpressionClause {
+//		
+//		List<ExpressionRangeVariable> variables;
+//		
+//		public List<ExpressionRangeVariable> Variables {
+//			get {
+//				return variables;
+//			}
+//			set {
+//				variables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public QueryExpressionLetClause() {
+//			variables = new List<ExpressionRangeVariable>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionLetVBClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionLetVBClause Variables={0}]", GetCollectionString(Variables));
+//		}
+//	}
+//	
+//	public class QueryExpressionOrderClause : QueryExpressionClause {
+//		
+//		List<QueryExpressionOrdering> orderings;
+//		
+//		public List<QueryExpressionOrdering> Orderings {
+//			get {
+//				return orderings;
+//			}
+//			set {
+//				orderings = value ?? new List<QueryExpressionOrdering>();
+//			}
+//		}
+//		
+//		public QueryExpressionOrderClause() {
+//			orderings = new List<QueryExpressionOrdering>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionOrderClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionOrderClause Orderings={0}]", GetCollectionString(Orderings));
+//		}
+//	}
+//	
+//	public class QueryExpressionOrdering : AbstractNode {
+//		
+//		Expression criteria;
+//		
+//		QueryExpressionOrderingDirection direction;
+//		
+//		public Expression Criteria {
+//			get {
+//				return criteria;
+//			}
+//			set {
+//				criteria = value ?? Expression.Null;
+//				if (!criteria.IsNull) criteria.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionOrderingDirection Direction {
+//			get {
+//				return direction;
+//			}
+//			set {
+//				direction = value;
+//			}
+//		}
+//		
+//		public QueryExpressionOrdering() {
+//			criteria = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionOrdering(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionOrdering Criteria={0} Direction={1}]", Criteria, Direction);
+//		}
+//	}
+//	
+//	public class QueryExpressionPartitionVBClause : QueryExpressionClause {
+//		
+//		Expression expression;
+//		
+//		QueryExpressionPartitionType partitionType;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionPartitionType PartitionType {
+//			get {
+//				return partitionType;
+//			}
+//			set {
+//				partitionType = value;
+//			}
+//		}
+//		
+//		public QueryExpressionPartitionVBClause() {
+//			expression = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionPartitionVBClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionPartitionVBClause Expression={0} PartitionType={1}]", Expression, PartitionType);
+//		}
+//	}
+//	
+//	public class QueryExpressionSelectClause : QueryExpressionClause {
+//		
+//		Expression projection;
+//		
+//		public Expression Projection {
+//			get {
+//				return projection;
+//			}
+//			set {
+//				projection = value ?? Expression.Null;
+//				if (!projection.IsNull) projection.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionSelectClause() {
+//			projection = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionSelectClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionSelectClause Projection={0}]", Projection);
+//		}
+//	}
+//	
+//	public class QueryExpressionSelectVBClause : QueryExpressionClause {
+//		
+//		List<ExpressionRangeVariable> variables;
+//		
+//		public List<ExpressionRangeVariable> Variables {
+//			get {
+//				return variables;
+//			}
+//			set {
+//				variables = value ?? new List<ExpressionRangeVariable>();
+//			}
+//		}
+//		
+//		public QueryExpressionSelectVBClause() {
+//			variables = new List<ExpressionRangeVariable>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionSelectVBClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionSelectVBClause Variables={0}]", GetCollectionString(Variables));
+//		}
+//	}
+//	
+//	public class QueryExpressionWhereClause : QueryExpressionClause {
+//		
+//		Expression condition;
+//		
+//		public Expression Condition {
+//			get {
+//				return condition;
+//			}
+//			set {
+//				condition = value ?? Expression.Null;
+//				if (!condition.IsNull) condition.Parent = this;
+//			}
+//		}
+//		
+//		public QueryExpressionWhereClause() {
+//			condition = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitQueryExpressionWhereClause(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[QueryExpressionWhereClause Condition={0}]", Condition);
+//		}
+//	}
+//	
+//	public class RaiseEventStatement : Statement {
+//		
+//		string eventName;
+//		
+//		List<Expression> arguments;
+//		
+//		public string EventName {
+//			get {
+//				return eventName;
+//			}
+//			set {
+//				eventName = value ?? "";
+//			}
+//		}
+//		
+//		public List<Expression> Arguments {
+//			get {
+//				return arguments;
+//			}
+//			set {
+//				arguments = value ?? new List<Expression>();
+//			}
+//		}
+//		
+//		public RaiseEventStatement(string eventName, List<Expression> arguments) {
+//			EventName = eventName;
+//			Arguments = arguments;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitRaiseEventStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[RaiseEventStatement EventName={0} Arguments={1}]", EventName, GetCollectionString(Arguments));
+//		}
+//	}
+//	
+//	public class ReDimStatement : Statement {
+//		
+//		List<InvocationExpression> reDimClauses;
+//		
+//		bool isPreserve;
+//		
+//		public List<InvocationExpression> ReDimClauses {
+//			get {
+//				return reDimClauses;
+//			}
+//			set {
+//				reDimClauses = value ?? new List<InvocationExpression>();
+//			}
+//		}
+//		
+//		public bool IsPreserve {
+//			get {
+//				return isPreserve;
+//			}
+//			set {
+//				isPreserve = value;
+//			}
+//		}
+//		
+//		public ReDimStatement(bool isPreserve) {
+//			IsPreserve = isPreserve;
+//			reDimClauses = new List<InvocationExpression>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitReDimStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ReDimStatement ReDimClauses={0} IsPreserve={1}]", GetCollectionString(ReDimClauses), IsPreserve);
+//		}
+//	}
+//	
+//	public class RemoveHandlerStatement : Statement {
+//		
+//		Expression eventExpression;
+//		
+//		Expression handlerExpression;
+//		
+//		public Expression EventExpression {
+//			get {
+//				return eventExpression;
+//			}
+//			set {
+//				eventExpression = value ?? Expression.Null;
+//				if (!eventExpression.IsNull) eventExpression.Parent = this;
+//			}
+//		}
+//		
+//		public Expression HandlerExpression {
+//			get {
+//				return handlerExpression;
+//			}
+//			set {
+//				handlerExpression = value ?? Expression.Null;
+//				if (!handlerExpression.IsNull) handlerExpression.Parent = this;
+//			}
+//		}
+//		
+//		public RemoveHandlerStatement(Expression eventExpression, Expression handlerExpression) {
+//			EventExpression = eventExpression;
+//			HandlerExpression = handlerExpression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitRemoveHandlerStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[RemoveHandlerStatement EventExpression={0} HandlerExpression={1}]", EventExpression, HandlerExpression);
+//		}
+//	}
+//	
+//	public class ResumeStatement : Statement {
+//		
+//		string labelName;
+//		
+//		bool isResumeNext;
+//		
+//		public string LabelName {
+//			get {
+//				return labelName;
+//			}
+//			set {
+//				labelName = value ?? "";
+//			}
+//		}
+//		
+//		public bool IsResumeNext {
+//			get {
+//				return isResumeNext;
+//			}
+//			set {
+//				isResumeNext = value;
+//			}
+//		}
+//		
+//		public ResumeStatement(bool isResumeNext) {
+//			IsResumeNext = isResumeNext;
+//			labelName = "";
+//		}
+//		
+//		public ResumeStatement(string labelName) {
+//			LabelName = labelName;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitResumeStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ResumeStatement LabelName={0} IsResumeNext={1}]", LabelName, IsResumeNext);
+//		}
+//	}
+//	
+//	public class ReturnStatement : Statement {
+//		
+//		Expression expression;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public ReturnStatement(Expression expression) {
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitReturnStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ReturnStatement Expression={0}]", Expression);
+//		}
+//	}
+//	
+//	public class StopStatement : Statement {
+//		
+//		public StopStatement() {
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitStopStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return "[StopStatement]";
+//		}
+//	}
+//	
+//	public class SwitchSection : BlockStatement {
+//		
+//		List<CaseLabel> switchLabels;
+//		
+//		public List<CaseLabel> SwitchLabels {
+//			get {
+//				return switchLabels;
+//			}
+//			set {
+//				switchLabels = value ?? new List<CaseLabel>();
+//			}
+//		}
+//		
+//		public SwitchSection() {
+//			switchLabels = new List<CaseLabel>();
+//		}
+//		
+//		public SwitchSection(List<CaseLabel> switchLabels) {
+//			SwitchLabels = switchLabels;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitSwitchSection(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[SwitchSection SwitchLabels={0}]", GetCollectionString(SwitchLabels));
+//		}
+//	}
+//	
+//	public class SwitchStatement : Statement {
+//		
+//		Expression switchExpression;
+//		
+//		List<SwitchSection> switchSections;
+//		
+//		public Expression SwitchExpression {
+//			get {
+//				return switchExpression;
+//			}
+//			set {
+//				switchExpression = value ?? Expression.Null;
+//				if (!switchExpression.IsNull) switchExpression.Parent = this;
+//			}
+//		}
+//		
+//		public List<SwitchSection> SwitchSections {
+//			get {
+//				return switchSections;
+//			}
+//			set {
+//				switchSections = value ?? new List<SwitchSection>();
+//			}
+//		}
+//		
+//		public SwitchStatement(Expression switchExpression, List<SwitchSection> switchSections) {
+//			SwitchExpression = switchExpression;
+//			SwitchSections = switchSections;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitSwitchStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[SwitchStatement SwitchExpression={0} SwitchSections={1}]", SwitchExpression, GetCollectionString(SwitchSections));
+//		}
+//	}
+//	
+//	public class TemplateDefinition : AttributedNode {
+//		
+//		string name;
+//		
+//		VarianceModifier varianceModifier;
+//		
+//		List<TypeReference> bases;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = string.IsNullOrEmpty(value) ? "?" : value;
+//			}
+//		}
+//		
+//		public VarianceModifier VarianceModifier {
+//			get {
+//				return varianceModifier;
+//			}
+//			set {
+//				varianceModifier = value;
+//			}
+//		}
+//		
+//		public List<TypeReference> Bases {
+//			get {
+//				return bases;
+//			}
+//			set {
+//				bases = value ?? new List<TypeReference>();
+//			}
+//		}
+//		
+//		public TemplateDefinition() {
+//			name = "?";
+//			bases = new List<TypeReference>();
+//		}
+//		
+//		public TemplateDefinition(string name, List<AttributeSection> attributes) {
+//			Name = name;
+//			Attributes = attributes;
+//			bases = new List<TypeReference>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitTemplateDefinition(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[TemplateDefinition Name={0} VarianceModifier={1} Bases={2} Attributes={3} Modifi" +
+//			                     "er={4}]", Name, VarianceModifier, GetCollectionString(Bases), GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class ThisReferenceExpression : Expression {
+//		
+//		public ThisReferenceExpression() {
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitThisReferenceExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return "[ThisReferenceExpression]";
+//		}
+//	}
+//	
+//	public class ThrowStatement : Statement {
+//		
+//		Expression expression;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public ThrowStatement(Expression expression) {
+//			Expression = expression;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitThrowStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[ThrowStatement Expression={0}]", Expression);
+//		}
+//	}
+//	
+//	public class TryCatchStatement : Statement {
+//		
+//		Statement statementBlock;
+//		
+//		List<CatchClause> catchClauses;
+//		
+//		Statement finallyBlock;
+//		
+//		public Statement StatementBlock {
+//			get {
+//				return statementBlock;
+//			}
+//			set {
+//				statementBlock = value ?? Statement.Null;
+//				if (!statementBlock.IsNull) statementBlock.Parent = this;
+//			}
+//		}
+//		
+//		public List<CatchClause> CatchClauses {
+//			get {
+//				return catchClauses;
+//			}
+//			set {
+//				catchClauses = value ?? new List<CatchClause>();
+//			}
+//		}
+//		
+//		public Statement FinallyBlock {
+//			get {
+//				return finallyBlock;
+//			}
+//			set {
+//				finallyBlock = value ?? Statement.Null;
+//				if (!finallyBlock.IsNull) finallyBlock.Parent = this;
+//			}
+//		}
+//		
+//		public TryCatchStatement(Statement statementBlock, List<CatchClause> catchClauses, Statement finallyBlock) {
+//			StatementBlock = statementBlock;
+//			CatchClauses = catchClauses;
+//			FinallyBlock = finallyBlock;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitTryCatchStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[TryCatchStatement StatementBlock={0} CatchClauses={1} FinallyBlock={2}]", StatementBlock, GetCollectionString(CatchClauses), FinallyBlock);
+//		}
+//	}
+//	
+//	public class TypeDeclaration : AttributedNode {
+//		
+//		string name;
+//		
+//		ClassType type;
+//		
+//		List<TypeReference> baseTypes;
+//		
+//		List<TemplateDefinition> templates;
+//		
+//		Location bodyStartLocation;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public ClassType Type {
+//			get {
+//				return type;
+//			}
+//			set {
+//				type = value;
+//			}
+//		}
+//		
+//		public List<TypeReference> BaseTypes {
+//			get {
+//				return baseTypes;
+//			}
+//			set {
+//				baseTypes = value ?? new List<TypeReference>();
+//			}
+//		}
+//		
+//		public List<TemplateDefinition> Templates {
+//			get {
+//				return templates;
+//			}
+//			set {
+//				templates = value ?? new List<TemplateDefinition>();
+//			}
+//		}
+//		
+//		public Location BodyStartLocation {
+//			get {
+//				return bodyStartLocation;
+//			}
+//			set {
+//				bodyStartLocation = value;
+//			}
+//		}
+//		
+//		public TypeDeclaration(Modifiers modifier, List<AttributeSection> attributes) {
+//			Modifier = modifier;
+//			Attributes = attributes;
+//			name = "";
+//			baseTypes = new List<TypeReference>();
+//			templates = new List<TemplateDefinition>();
+//			bodyStartLocation = Location.Empty;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitTypeDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[TypeDeclaration Name={0} Type={1} BaseTypes={2} Templates={3} BodyStartLocation=" +
+//			                     "{4} Attributes={5} Modifier={6}]", Name, Type, GetCollectionString(BaseTypes), GetCollectionString(Templates), BodyStartLocation, GetCollectionString(Attributes), Modifier);
+//		}
+//	}
+//	
+//	public class TypeOfExpression : Expression {
+//		
+//		TypeReference typeReference;
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public TypeOfExpression(TypeReference typeReference) {
+//			TypeReference = typeReference;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitTypeOfExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[TypeOfExpression TypeReference={0}]", TypeReference);
+//		}
+//	}
+//	
+//	public class TypeOfIsExpression : Expression {
+//		
+//		Expression expression;
+//		
+//		TypeReference typeReference;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public TypeOfIsExpression(Expression expression, TypeReference typeReference) {
+//			Expression = expression;
+//			TypeReference = typeReference;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitTypeOfIsExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[TypeOfIsExpression Expression={0} TypeReference={1}]", Expression, TypeReference);
+//		}
+//	}
+//	
+//	public class TypeReferenceExpression : Expression {
+//		
+//		TypeReference typeReference;
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public TypeReferenceExpression(TypeReference typeReference) {
+//			TypeReference = typeReference;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitTypeReferenceExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[TypeReferenceExpression TypeReference={0}]", TypeReference);
+//		}
+//	}
+//	
+//	public class UnaryOperatorExpression : Expression {
+//		
+//		UnaryOperatorType op;
+//		
+//		Expression expression;
+//		
+//		public UnaryOperatorType Op {
+//			get {
+//				return op;
+//			}
+//			set {
+//				op = value;
+//			}
+//		}
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public UnaryOperatorExpression(UnaryOperatorType op) {
+//			Op = op;
+//			expression = Expression.Null;
+//		}
+//		
+//		public UnaryOperatorExpression(Expression expression, UnaryOperatorType op) {
+//			Expression = expression;
+//			Op = op;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitUnaryOperatorExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[UnaryOperatorExpression Op={0} Expression={1}]", Op, Expression);
+//		}
+//	}
+//	
+//	public class UsingStatement : StatementWithEmbeddedStatement {
+//		
+//		Statement resourceAcquisition;
+//		
+//		public Statement ResourceAcquisition {
+//			get {
+//				return resourceAcquisition;
+//			}
+//			set {
+//				resourceAcquisition = value ?? Statement.Null;
+//				if (!resourceAcquisition.IsNull) resourceAcquisition.Parent = this;
+//			}
+//		}
+//		
+//		public UsingStatement(Statement resourceAcquisition, Statement embeddedStatement) {
+//			ResourceAcquisition = resourceAcquisition;
+//			EmbeddedStatement = embeddedStatement;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitUsingStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[UsingStatement ResourceAcquisition={0} EmbeddedStatement={1}]", ResourceAcquisition, EmbeddedStatement);
+//		}
+//	}
+//	
+//	public class VariableDeclaration : AbstractNode {
+//		
+//		string name;
+//		
+//		Expression initializer;
+//		
+//		TypeReference typeReference;
+//		
+//		Expression fixedArrayInitialization;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public Expression Initializer {
+//			get {
+//				return initializer;
+//			}
+//			set {
+//				initializer = value ?? Expression.Null;
+//				if (!initializer.IsNull) initializer.Parent = this;
+//			}
+//		}
+//		
+//		public TypeReference TypeReference {
+//			get {
+//				return typeReference;
+//			}
+//			set {
+//				typeReference = value ?? TypeReference.Null;
+//				if (!typeReference.IsNull) typeReference.Parent = this;
+//			}
+//		}
+//		
+//		public Expression FixedArrayInitialization {
+//			get {
+//				return fixedArrayInitialization;
+//			}
+//			set {
+//				fixedArrayInitialization = value ?? Expression.Null;
+//				if (!fixedArrayInitialization.IsNull) fixedArrayInitialization.Parent = this;
+//			}
+//		}
+//		
+//		public VariableDeclaration(string name) {
+//			Name = name;
+//			initializer = Expression.Null;
+//			typeReference = TypeReference.Null;
+//			fixedArrayInitialization = Expression.Null;
+//		}
+//		
+//		public VariableDeclaration(string name, Expression initializer) {
+//			Name = name;
+//			Initializer = initializer;
+//			typeReference = TypeReference.Null;
+//			fixedArrayInitialization = Expression.Null;
+//		}
+//		
+//		public VariableDeclaration(string name, Expression initializer, TypeReference typeReference) {
+//			Name = name;
+//			Initializer = initializer;
+//			TypeReference = typeReference;
+//			fixedArrayInitialization = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitVariableDeclaration(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[VariableDeclaration Name={0} Initializer={1} TypeReference={2} FixedArrayInitial" +
+//			                     "ization={3}]", Name, Initializer, TypeReference, FixedArrayInitialization);
+//		}
+//	}
+//	
+//	public class WithStatement : Statement {
+//		
+//		Expression expression;
+//		
+//		BlockStatement body;
+//		
+//		public Expression Expression {
+//			get {
+//				return expression;
+//			}
+//			set {
+//				expression = value ?? Expression.Null;
+//				if (!expression.IsNull) expression.Parent = this;
+//			}
+//		}
+//		
+//		public BlockStatement Body {
+//			get {
+//				return body;
+//			}
+//			set {
+//				body = value ?? BlockStatement.Null;
+//				if (!body.IsNull) body.Parent = this;
+//			}
+//		}
+//		
+//		public WithStatement(Expression expression) {
+//			Expression = expression;
+//			body = BlockStatement.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitWithStatement(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[WithStatement Expression={0} Body={1}]", Expression, Body);
+//		}
+//	}
+//	
+//	public class XmlAttributeExpression : XmlExpression {
+//		
+//		string name;
+//		
+//		string literalValue;
+//		
+//		bool useDoubleQuotes;
+//		
+//		Expression expressionValue;
+//		
+//		public string Name {
+//			get {
+//				return name;
+//			}
+//			set {
+//				name = value ?? "";
+//			}
+//		}
+//		
+//		public string LiteralValue {
+//			get {
+//				return literalValue;
+//			}
+//			set {
+//				literalValue = value ?? "";
+//			}
+//		}
+//		
+//		public bool UseDoubleQuotes {
+//			get {
+//				return useDoubleQuotes;
+//			}
+//			set {
+//				useDoubleQuotes = value;
+//			}
+//		}
+//		
+//		public Expression ExpressionValue {
+//			get {
+//				return expressionValue;
+//			}
+//			set {
+//				expressionValue = value ?? Expression.Null;
+//				if (!expressionValue.IsNull) expressionValue.Parent = this;
+//			}
+//		}
+//		
+//		public XmlAttributeExpression() {
+//			name = "";
+//			literalValue = "";
+//			expressionValue = Expression.Null;
+//		}
+//		
+//		public bool IsLiteralValue {
+//			get {
+//				return expressionValue.IsNull;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitXmlAttributeExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[XmlAttributeExpression Name={0} LiteralValue={1} UseDoubleQuotes={2} ExpressionV" +
+//			                     "alue={3}]", Name, LiteralValue, UseDoubleQuotes, ExpressionValue);
+//		}
+//	}
+//	
+//	public class XmlContentExpression : XmlExpression {
+//		
+//		string content;
+//		
+//		XmlContentType type;
+//		
+//		public string Content {
+//			get {
+//				return content;
+//			}
+//			set {
+//				content = value ?? "";
+//			}
+//		}
+//		
+//		public XmlContentType Type {
+//			get {
+//				return type;
+//			}
+//			set {
+//				type = value;
+//			}
+//		}
+//		
+//		public XmlContentExpression(string content, XmlContentType type) {
+//			Content = content;
+//			Type = type;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitXmlContentExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[XmlContentExpression Content={0} Type={1}]", Content, Type);
+//		}
+//	}
+//	
+//	public class XmlDocumentExpression : XmlExpression {
+//		
+//		List<XmlExpression> expressions;
+//		
+//		public List<XmlExpression> Expressions {
+//			get {
+//				return expressions;
+//			}
+//			set {
+//				expressions = value ?? new List<XmlExpression>();
+//			}
+//		}
+//		
+//		public XmlDocumentExpression() {
+//			expressions = new List<XmlExpression>();
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitXmlDocumentExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[XmlDocumentExpression Expressions={0}]", GetCollectionString(Expressions));
+//		}
+//	}
+//	
+//	public class XmlElementExpression : XmlExpression {
+//		
+//		Expression content;
+//		
+//		Expression nameExpression;
+//		
+//		string xmlName;
+//		
+//		List<XmlExpression> attributes;
+//		
+//		public Expression Content {
+//			get {
+//				return content;
+//			}
+//			set {
+//				content = value ?? Expression.Null;
+//				if (!content.IsNull) content.Parent = this;
+//			}
+//		}
+//		
+//		public Expression NameExpression {
+//			get {
+//				return nameExpression;
+//			}
+//			set {
+//				nameExpression = value ?? Expression.Null;
+//				if (!nameExpression.IsNull) nameExpression.Parent = this;
+//			}
+//		}
+//		
+//		public string XmlName {
+//			get {
+//				return xmlName;
+//			}
+//			set {
+//				xmlName = value ?? "";
+//			}
+//		}
+//		
+//		public List<XmlExpression> Attributes {
+//			get {
+//				return attributes;
+//			}
+//			set {
+//				attributes = value ?? new List<XmlExpression>();
+//			}
+//		}
+//		
+//		public XmlElementExpression() {
+//			content = Expression.Null;
+//			nameExpression = Expression.Null;
+//			xmlName = "";
+//			attributes = new List<XmlExpression>();
+//		}
+//		
+//		public bool IsExpression {
+//			get {
+//				return !content.IsNull;
+//			}
+//		}
+//		
+//		public bool NameIsExpression {
+//			get {
+//				return !nameExpression.IsNull;
+//			}
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitXmlElementExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[XmlElementExpression Content={0} NameExpression={1} XmlName={2} Attributes={3}]", Content, NameExpression, XmlName, GetCollectionString(Attributes));
+//		}
+//	}
+//	
+//	public class XmlEmbeddedExpression : XmlExpression {
+//		
+//		Expression inlineVBExpression;
+//		
+//		public Expression InlineVBExpression {
+//			get {
+//				return inlineVBExpression;
+//			}
+//			set {
+//				inlineVBExpression = value ?? Expression.Null;
+//				if (!inlineVBExpression.IsNull) inlineVBExpression.Parent = this;
+//			}
+//		}
+//		
+//		public XmlEmbeddedExpression() {
+//			inlineVBExpression = Expression.Null;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitXmlEmbeddedExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[XmlEmbeddedExpression InlineVBExpression={0}]", InlineVBExpression);
+//		}
+//	}
+//	
+//	public abstract class XmlExpression : Expression {
+//		
+//		protected XmlExpression() {
+//		}
+//	}
+//	
+//	public class XmlMemberAccessExpression : Expression {
+//		
+//		Expression targetObject;
+//		
+//		XmlAxisType axisType;
+//		
+//		bool isXmlIdentifier;
+//		
+//		string identifier;
+//		
+//		public Expression TargetObject {
+//			get {
+//				return targetObject;
+//			}
+//			set {
+//				targetObject = value ?? Expression.Null;
+//				if (!targetObject.IsNull) targetObject.Parent = this;
+//			}
+//		}
+//		
+//		public XmlAxisType AxisType {
+//			get {
+//				return axisType;
+//			}
+//			set {
+//				axisType = value;
+//			}
+//		}
+//		
+//		public bool IsXmlIdentifier {
+//			get {
+//				return isXmlIdentifier;
+//			}
+//			set {
+//				isXmlIdentifier = value;
+//			}
+//		}
+//		
+//		public string Identifier {
+//			get {
+//				return identifier;
+//			}
+//			set {
+//				identifier = value ?? "";
+//			}
+//		}
+//		
+//		public XmlMemberAccessExpression(Expression targetObject, XmlAxisType axisType, string identifier, bool isXmlIdentifier) {
+//			TargetObject = targetObject;
+//			AxisType = axisType;
+//			Identifier = identifier;
+//			IsXmlIdentifier = isXmlIdentifier;
+//		}
+//		
+//		public override object AcceptVisitor(IAstVisitor visitor, object data) {
+//			return visitor.VisitXmlMemberAccessExpression(this, data);
+//		}
+//		
+//		public override string ToString() {
+//			return string.Format("[XmlMemberAccessExpression TargetObject={0} AxisType={1} IsXmlIdentifier={2} Iden" +
+//			                     "tifier={3}]", TargetObject, AxisType, IsXmlIdentifier, Identifier);
+//		}
+//	}
+//}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/DelegateDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/DelegateDeclaration.cs
new file mode 100644
index 000000000..bc2d06ca0
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/DelegateDeclaration.cs
@@ -0,0 +1,52 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class DelegateDeclaration : AttributedNode
+	{
+		public bool IsSub { get; set; }
+		
+		public AstNodeCollection<TypeParameterDeclaration> TypeParameters {
+			get { return GetChildrenByRole(Roles.TypeParameter); }
+		}
+		
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public AstNodeCollection<ParameterDeclaration> Parameters {
+			get { return GetChildrenByRole(Roles.Parameter); }
+		}
+		
+		public AstNodeCollection<AttributeBlock> ReturnTypeAttributes {
+			get { return GetChildrenByRole(AttributeBlock.ReturnTypeAttributeBlockRole); }
+		}
+		
+		public AstType ReturnType {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var o = other as DelegateDeclaration;
+			return o != null &&
+				MatchAttributesAndModifiers(o, match) &&
+				IsSub == o.IsSub &&
+				TypeParameters.DoMatch(o.TypeParameters, match) &&
+				Name.DoMatch(o.Name, match) &&
+				Parameters.DoMatch(o.Parameters, match) &&
+				ReturnTypeAttributes.DoMatch(o.ReturnTypeAttributes, match) &&
+				ReturnType.DoMatch(o.ReturnType, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitDelegateDeclaration(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/EnumDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/EnumDeclaration.cs
new file mode 100644
index 000000000..49fe3f239
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/EnumDeclaration.cs
@@ -0,0 +1,44 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class EnumDeclaration : AttributedNode
+	{
+		public readonly static Role<EnumMemberDeclaration> MemberRole = new Role<EnumMemberDeclaration>("Member");
+		public readonly static Role<AstType> UnderlyingTypeRole = new Role<AstType>("UnderlyingType", AstType.Null);
+
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public AstType UnderlyingType {
+			get { return GetChildByRole(UnderlyingTypeRole); }
+			set { SetChildByRole(UnderlyingTypeRole, value); }
+		}
+		
+		public AstNodeCollection<EnumMemberDeclaration> Member {
+			get { return GetChildrenByRole(MemberRole); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var decl = other as EnumDeclaration;
+			return decl != null &&
+				MatchAttributesAndModifiers(decl, match) &&
+				Name.DoMatch(decl.Name, match) &&
+				UnderlyingType.DoMatch(decl.UnderlyingType, match) &&
+				Member.DoMatch(decl.Member, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitEnumDeclaration(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/EnumMemberDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/EnumMemberDeclaration.cs
new file mode 100644
index 000000000..476ec5636
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/EnumMemberDeclaration.cs
@@ -0,0 +1,39 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class EnumMemberDeclaration : AstNode
+	{
+		public AstNodeCollection<AttributeBlock> Attributes {
+			get { return GetChildrenByRole(AttributeBlock.AttributeBlockRole); }
+		}
+		
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public Expression Value {
+			get { return GetChildByRole(Roles.Expression); }
+			set { SetChildByRole(Roles.Expression, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var member = other as EnumMemberDeclaration;
+			return Attributes.DoMatch(member.Attributes, match) &&
+				Name.DoMatch(member.Name, match) &&
+				Value.DoMatch(member.Value, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitEnumMemberDeclaration(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/ImportsClause.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/ImportsClause.cs
new file mode 100644
index 000000000..15730eab0
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/ImportsClause.cs
@@ -0,0 +1,113 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public abstract class ImportsClause : AstNode
+	{
+		public new static readonly ImportsClause Null = new NullImportsClause();
+		
+		class NullImportsClause : ImportsClause
+		{
+			public override bool IsNull {
+				get { return true; }
+			}
+			
+			protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+			{
+				return other != null && other.IsNull;
+			}
+			
+			public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+			{
+				return default(S);
+			}
+		}
+	}
+	
+	public class AliasImportsClause : ImportsClause
+	{
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public AstType Alias {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var clause = other as AliasImportsClause;
+			return clause != null
+				&& Name.DoMatch(clause.Name, match)
+				&& Alias.DoMatch(clause.Alias, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitAliasImportsClause(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[AliasImportsClause Name={0} Alias={1}]", Name, Alias);
+		}
+	}
+	
+	public class MemberImportsClause : ImportsClause
+	{
+		public AstType Member {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var node = other as MemberImportsClause;
+			return node != null
+				&& Member.DoMatch(node.Member, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitMembersImportsClause(this, data);
+		}
+		
+		public override string ToString()
+		{
+			return string.Format("[MemberImportsClause Member={0}]", Member);
+		}
+	}
+	
+	public class XmlNamespaceImportsClause : ImportsClause
+	{
+		public XmlIdentifier Prefix {
+			get { return GetChildByRole(Roles.XmlIdentifier); }
+			set { SetChildByRole(Roles.XmlIdentifier, value); }
+		}
+		
+		public XmlLiteralString Namespace {
+			get { return GetChildByRole(Roles.XmlLiteralString); }
+			set { SetChildByRole(Roles.XmlLiteralString, value); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var clause = other as XmlNamespaceImportsClause;
+			return clause != null && Namespace.DoMatch(clause.Namespace, match) && Prefix.DoMatch(clause.Prefix, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitXmlNamespaceImportsClause(this, data);
+		}
+		
+		public override string ToString()
+		{
+			return string.Format("[XmlNamespaceImportsClause Prefix={0}, Namespace={1}]", Prefix, Namespace);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/ImportsStatement.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/ImportsStatement.cs
new file mode 100644
index 000000000..6691b852b
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/ImportsStatement.cs
@@ -0,0 +1,36 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+using System;
+using System.Collections.Generic;
+using ICSharpCode.NRefactory.PatternMatching;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class ImportsStatement : AstNode
+	{
+		public static readonly Role<ImportsClause> ImportsClauseRole = new Role<ImportsClause>("ImportsClause", ImportsClause.Null);
+		
+		public VBTokenNode Imports {
+			get { return GetChildByRole(Roles.Keyword); }
+		}
+		
+		public AstNodeCollection<ImportsClause> ImportsClauses {
+			get { return GetChildrenByRole(ImportsClauseRole); }
+		}
+		
+//		public override string ToString() {
+//			return string.Format("[ImportsStatement ImportsClauses={0}]", GetCollectionString(ImportsClauses));
+//		}
+		
+		protected internal override bool DoMatch(AstNode other, Match match)
+		{
+			ImportsStatement stmt = other as ImportsStatement;
+			return stmt != null && stmt.ImportsClauses.DoMatch(ImportsClauses, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitImportsStatement(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/NamespaceDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/NamespaceDeclaration.cs
new file mode 100644
index 000000000..b91a753e0
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/NamespaceDeclaration.cs
@@ -0,0 +1,78 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using ICSharpCode.NRefactory.PatternMatching;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Namespace Name
+	/// 	Members
+	/// End Namespace
+	/// </summary>
+	public class NamespaceDeclaration : AstNode
+	{
+		public static readonly Role<AstNode> MemberRole = CompilationUnit.MemberRole;
+		
+		public string Name {
+			get {
+				StringBuilder builder = new StringBuilder();
+				foreach (Identifier identifier in GetChildrenByRole (Roles.Identifier)) {
+					if (builder.Length > 0)
+						builder.Append ('.');
+					builder.Append (identifier.Name);
+				}
+				return builder.ToString ();
+			}
+			set {
+				GetChildrenByRole(Roles.Identifier).ReplaceWith(value.Split('.').Select(ident => new Identifier(ident, AstLocation.Empty)));
+			}
+		}
+		
+		public AstNodeCollection<Identifier> Identifiers {
+			get { return GetChildrenByRole (Roles.Identifier); }
+		}
+		
+		/// <summary>
+		/// Gets the full namespace name (including any parent namespaces)
+		/// </summary>
+		public string FullName {
+			get {
+				NamespaceDeclaration parentNamespace = Parent as NamespaceDeclaration;
+				if (parentNamespace != null)
+					return BuildQualifiedName (parentNamespace.FullName, Name);
+				return Name;
+			}
+		}
+		
+		public AstNodeCollection<AstNode> Members {
+			get { return GetChildrenByRole(MemberRole); }
+		}
+		
+		public static string BuildQualifiedName (string name1, string name2)
+		{
+			if (string.IsNullOrEmpty (name1))
+				return name2;
+			if (string.IsNullOrEmpty (name2))
+				return name1;
+			return name1 + "." + name2;
+		}
+		
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitNamespaceDeclaration(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			NamespaceDeclaration o = other as NamespaceDeclaration;
+			return o != null && MatchString(this.Name, o.Name) && this.Members.DoMatch(o.Members, match);
+		}
+	}
+};
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/OptionStatement.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/OptionStatement.cs
new file mode 100644
index 000000000..903439c89
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/OptionStatement.cs
@@ -0,0 +1,60 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+using System;
+using System.Collections.Generic;
+using ICSharpCode.NRefactory.PatternMatching;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class OptionStatement : AstNode
+	{
+		public static readonly Role<VBTokenNode> OptionTypeRole = new Role<VBTokenNode>("OptionType");
+		public static readonly Role<VBTokenNode> OptionValueRole = new Role<VBTokenNode>("OptionValue");
+
+		public VBTokenNode OptionKeyword {
+			get { return GetChildByRole(Roles.Keyword); }
+		}
+		
+		public VBTokenNode OptionTypeKeyword {
+			get { return GetChildByRole(OptionTypeRole); }
+		}
+		
+		public VBTokenNode OptionValueKeyword {
+			get { return GetChildByRole(OptionValueRole); }
+		}
+
+		public OptionType OptionType { get; set; }
+
+		public OptionValue OptionValue { get; set; }
+		
+		protected internal override bool DoMatch(AstNode other, Match match)
+		{
+			var stmt = other as OptionStatement;
+			return stmt != null && stmt.OptionType == this.OptionType
+				&& stmt.OptionValue == this.OptionValue;
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitOptionStatement(this, data);
+		}
+		
+		public override string ToString() {
+			return string.Format("[OptionStatement OptionType={0} OptionValue={1}]", OptionType, OptionValue);
+		}
+	}
+	
+	public enum OptionType
+	{
+		Explicit,
+		Strict,
+		Compare,
+		Infer
+	}
+	
+	public enum OptionValue
+	{
+		On, Off,
+		Text, Binary
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/TypeDeclaration.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/TypeDeclaration.cs
new file mode 100644
index 000000000..28b669d9c
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/GlobalScope/TypeDeclaration.cs
@@ -0,0 +1,58 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ICSharpCode.NRefactory.TypeSystem;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class TypeDeclaration : AttributedNode
+	{
+		public readonly static Role<AttributedNode> MemberRole = new Role<AttributedNode>("Member");
+		public readonly static Role<AstType> InheritsTypeRole = new Role<AstType>("InheritsType", AstType.Null);
+		public readonly static Role<AstType> ImplementsTypesRole = new Role<AstType>("ImplementsTypes", AstType.Null);
+
+		public AstNodeCollection<AttributedNode> Members {
+			get { return base.GetChildrenByRole(MemberRole); }
+		}
+		
+		public ClassType ClassType { get; set; }
+		
+		public Identifier Name {
+			get { return GetChildByRole(Roles.Identifier); }
+			set { SetChildByRole(Roles.Identifier, value); }
+		}
+		
+		public AstNodeCollection<TypeParameterDeclaration> TypeParameters {
+			get { return GetChildrenByRole(Roles.TypeParameter); }
+		}
+		
+		public AstType InheritsType {
+			get { return GetChildByRole(InheritsTypeRole); }
+		}
+		
+		public AstNodeCollection<AstType> ImplementsTypes {
+			get { return GetChildrenByRole(ImplementsTypesRole); }
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			TypeDeclaration t = other as TypeDeclaration;
+			return t != null &&
+				MatchAttributesAndModifiers(t, match) &&
+				Members.DoMatch(t.Members, match) &&
+				ClassType == t.ClassType &&
+				Name.DoMatch(t.Name, match) &&
+				TypeParameters.DoMatch(t.TypeParameters, match) &&
+				InheritsType.DoMatch(t.InheritsType, match) &&
+				ImplementsTypes.DoMatch(t.ImplementsTypes, match);
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitTypeDeclaration(this, data);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/INode.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/INode.cs
deleted file mode 100644
index f64420108..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/INode.cs
+++ /dev/null
@@ -1,51 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public interface INode
-	{
-		INode Parent { 
-			get;
-			set;
-		}
-		
-		List<INode> Children {
-			get;
-		}
-		
-		Location StartLocation {
-			get;
-			set;
-		}
-		
-		Location EndLocation {
-			get;
-			set;
-		}
-		
-		object UserData {
-			get;
-			set;
-		}
-		
-		/// <summary>
-		/// Visits all children
-		/// </summary>
-		/// <param name="visitor">The visitor to accept</param>
-		/// <param name="data">Additional data for the visitor</param>
-		/// <returns>The paremeter <paramref name="data"/></returns>
-		object AcceptChildren(IAstVisitor visitor, object data);
-		
-		/// <summary>
-		/// Accept the visitor
-		/// </summary>
-		/// <param name="visitor">The visitor to accept</param>
-		/// <param name="data">Additional data for the visitor</param>
-		/// <returns>The value the visitor returns after the visit</returns>
-		object AcceptVisitor(IAstVisitor visitor, object data);
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Identifier.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Identifier.cs
new file mode 100644
index 000000000..ea308b7f9
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Identifier.cs
@@ -0,0 +1,91 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Represents an identifier in VB.
+	/// </summary>
+	public class Identifier : AstNode
+	{
+		public static readonly new Identifier Null = new NullIdentifier ();
+		class NullIdentifier : Identifier
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default (S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		
+		string name;
+		
+		public string Name {
+			get { return name; }
+			set {
+				if (value == null)
+					throw new ArgumentNullException("value");
+				name = value;
+			}
+		}
+		
+		public TypeCode TypeCharacter { get; set; }
+		
+		AstLocation startLocation;
+		public override AstLocation StartLocation {
+			get {
+				return startLocation;
+			}
+		}
+		
+		public override AstLocation EndLocation {
+			get {
+				return new AstLocation (StartLocation.Line, StartLocation.Column + Name.Length);
+			}
+		}
+		
+		private Identifier()
+		{
+			this.name = string.Empty;
+		}
+		
+		public Identifier (string name, AstLocation location)
+		{
+			if (name == null)
+				throw new ArgumentNullException("name");
+			this.Name = name;
+			this.startLocation = location;
+		}
+		
+		protected internal override bool DoMatch(AstNode other, ICSharpCode.NRefactory.PatternMatching.Match match)
+		{
+			var node = other as Identifier;
+			return node != null
+				&& MatchString(node.name, name)
+				&& node.TypeCharacter == TypeCharacter;
+		}
+		
+		public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitIdentifier(this, data);
+		}
+		
+		public override string ToString()
+		{
+			return string.Format("[Identifier Name={0}, StartLocation={1}, TypeCharacter{4}]",
+			                     name, startLocation, TypeCharacter);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Statements/BlockStatement.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Statements/BlockStatement.cs
new file mode 100644
index 000000000..73610fe70
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Statements/BlockStatement.cs
@@ -0,0 +1,125 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// { Statements }
+	/// </summary>
+	public class BlockStatement : Statement, IEnumerable<Statement>
+	{
+		public static readonly Role<Statement> StatementRole = new Role<Statement>("Statement", Statement.Null);
+		
+		#region Null
+		public static readonly new BlockStatement Null = new NullBlockStatement();
+		sealed class NullBlockStatement : BlockStatement
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default(S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		#endregion
+		
+		#region PatternPlaceholder
+		public static implicit operator BlockStatement(PatternMatching.Pattern pattern)
+		{
+			return pattern != null ? new PatternPlaceholder(pattern) : null;
+		}
+		
+		sealed class PatternPlaceholder : BlockStatement, PatternMatching.INode
+		{
+			readonly PatternMatching.Pattern child;
+			
+			public PatternPlaceholder(PatternMatching.Pattern child)
+			{
+				this.child = child;
+			}
+			
+			public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+			{
+				return visitor.VisitPatternPlaceholder(this, child, data);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return child.DoMatch(other, match);
+			}
+			
+			bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo)
+			{
+				return child.DoMatchCollection(role, pos, match, backtrackingInfo);
+			}
+		}
+		#endregion
+		
+		public AstNodeCollection<Statement> Statements {
+			get { return GetChildrenByRole (StatementRole); }
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitBlockStatement (this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			BlockStatement o = other as BlockStatement;
+			return o != null && !o.IsNull && this.Statements.DoMatch(o.Statements, match);
+		}
+		
+		#region Builder methods
+		public void Add(Statement statement)
+		{
+			AddChild(statement, StatementRole);
+		}
+		
+		// TODO : uncomment
+		
+//		public void Add(Expression expression)
+//		{
+//			AddChild(new ExpressionStatement { Expression = expression }, StatementRole);
+//		}
+//		
+		public void AddRange(IEnumerable<Statement> statements)
+		{
+			foreach (Statement st in statements)
+				AddChild(st, StatementRole);
+		}
+		
+//		public void AddAssignment(Expression left, Expression right)
+//		{
+//			Add(new AssignmentExpression { Left = left, Operator = AssignmentOperatorType.Assign, Right = right });
+//		}
+//		
+//		public void AddReturnStatement(Expression expression)
+//		{
+//			Add(new ReturnStatement { Expression = expression });
+//		}
+		#endregion
+		
+		IEnumerator<Statement> IEnumerable<Statement>.GetEnumerator()
+		{
+			return this.Statements.GetEnumerator();
+		}
+		
+		System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
+		{
+			return this.Statements.GetEnumerator();
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/Statements/Statement.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Statements/Statement.cs
new file mode 100644
index 000000000..c20407051
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/Statements/Statement.cs
@@ -0,0 +1,132 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.IO;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Base class for statements.
+	/// </summary>
+	/// <remarks>
+	/// This class is useful even though it doesn't provide any additional functionality:
+	/// It can be used to communicate more information in APIs, e.g. "this subnode will always be a statement"
+	/// </remarks>
+	public abstract class Statement : AstNode
+	{
+		#region Null
+		public new static readonly Statement Null = new NullStatement ();
+		
+		sealed class NullStatement : Statement
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default (S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		#endregion
+		
+		#region PatternPlaceholder
+		public static implicit operator Statement(PatternMatching.Pattern pattern)
+		{
+			return pattern != null ? new PatternPlaceholder(pattern) : null;
+		}
+		
+		sealed class PatternPlaceholder : Statement, PatternMatching.INode
+		{
+			readonly PatternMatching.Pattern child;
+			
+			public PatternPlaceholder(PatternMatching.Pattern child)
+			{
+				this.child = child;
+			}
+			
+			public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+			{
+				return visitor.VisitPatternPlaceholder(this, child, data);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return child.DoMatch(other, match);
+			}
+			
+			bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo)
+			{
+				return child.DoMatchCollection(role, pos, match, backtrackingInfo);
+			}
+		}
+		#endregion
+		
+		/// <summary>
+		/// Gets the previous statement within the current block.
+		/// This is usually equivalent to <see cref="PrevSibling"/>, but will skip any non-statements (e.g. comments)
+		/// </summary>
+		public Statement PreviousStatement {
+			get {
+				AstNode node = this;
+				while ((node = node.PrevSibling) != null) {
+					Statement stmt = node as Statement;
+					if (stmt != null)
+						return stmt;
+				}
+				return null;
+			}
+		}
+		
+		/// <summary>
+		/// Gets the next statement within the current block.
+		/// This is usually equivalent to <see cref="NextSibling"/>, but will skip any non-statements (e.g. comments)
+		/// </summary>
+		public Statement NextStatement {
+			get {
+				AstNode node = this;
+				while ((node = node.NextSibling) != null) {
+					Statement stmt = node as Statement;
+					if (stmt != null)
+						return stmt;
+				}
+				return null;
+			}
+		}
+		
+		public new Statement Clone()
+		{
+			return (Statement)base.Clone();
+		}
+		
+		public Statement ReplaceWith(Func<Statement, Statement> replaceFunction)
+		{
+			if (replaceFunction == null)
+				throw new ArgumentNullException("replaceFunction");
+			return (Statement)base.ReplaceWith(node => replaceFunction((Statement)node));
+		}
+		
+		// Make debugging easier by giving Statements a ToString() implementation
+		public override string ToString()
+		{
+//			if (IsNull)
+//				return "Null";
+//			StringWriter w = new StringWriter();
+//			AcceptVisitor(new OutputVisitor(w, new CSharpFormattingOptions()), null);
+//			string text = w.ToString().TrimEnd().Replace("\t", "").Replace(w.NewLine, " ");
+//			if (text.Length > 100)
+//				return text.Substring(0, 97) + "...";
+//			else
+//				return text;
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/AstType.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/AstType.cs
new file mode 100644
index 000000000..13ba3ee97
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/AstType.cs
@@ -0,0 +1,145 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+using System;
+using System.Collections.Generic;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// A type reference in the VB AST.
+	/// </summary>
+	public abstract class AstType : AstNode
+	{
+		#region Null
+		public new static readonly AstType Null = new NullAstType();
+		
+		sealed class NullAstType : AstType
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default (S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		#endregion
+		
+		#region PatternPlaceholder
+		public static implicit operator AstType(PatternMatching.Pattern pattern)
+		{
+			return pattern != null ? new PatternPlaceholder(pattern) : null;
+		}
+		
+		sealed class PatternPlaceholder : AstType, PatternMatching.INode
+		{
+			readonly PatternMatching.Pattern child;
+			
+			public PatternPlaceholder(PatternMatching.Pattern child)
+			{
+				this.child = child;
+			}
+			
+			public override S AcceptVisitor<T, S>(IAstVisitor<T, S> visitor, T data)
+			{
+				return visitor.VisitPatternPlaceholder(this, child, data);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return child.DoMatch(other, match);
+			}
+			
+			bool PatternMatching.INode.DoMatchCollection(Role role, PatternMatching.INode pos, PatternMatching.Match match, PatternMatching.BacktrackingInfo backtrackingInfo)
+			{
+				return child.DoMatchCollection(role, pos, match, backtrackingInfo);
+			}
+		}
+		#endregion
+		
+		public virtual AstType MakeArrayType(int rank = 1)
+		{
+			return new ComposedType { BaseType = this }.MakeArrayType(rank);
+		}
+		
+		// TODO : reimplement this
+//		/// <summary>
+//		/// Builds an expression that can be used to access a static member on this type.
+//		/// </summary>
+//		public MemberReferenceExpression Member(string memberName)
+//		{
+//			return new TypeReferenceExpression { Type = this }.Member(memberName);
+//		}
+//		
+//		/// <summary>
+//		/// Builds an invocation expression using this type as target.
+//		/// </summary>
+//		public InvocationExpression Invoke(string methodName, IEnumerable<Expression> arguments)
+//		{
+//			return new TypeReferenceExpression { Type = this }.Invoke(methodName, arguments);
+//		}
+//		
+//		/// <summary>
+//		/// Builds an invocation expression using this type as target.
+//		/// </summary>
+//		public InvocationExpression Invoke(string methodName, params Expression[] arguments)
+//		{
+//			return new TypeReferenceExpression { Type = this }.Invoke(methodName, arguments);
+//		}
+//		
+//		/// <summary>
+//		/// Builds an invocation expression using this type as target.
+//		/// </summary>
+//		public InvocationExpression Invoke(string methodName, IEnumerable<AstType> typeArguments, IEnumerable<Expression> arguments)
+//		{
+//			return new TypeReferenceExpression { Type = this }.Invoke(methodName, typeArguments, arguments);
+//		}
+		
+		public static AstType Create(Type type)
+		{
+			switch (Type.GetTypeCode(type)) {
+				case TypeCode.Object:
+					return new PrimitiveType("Object");
+				case TypeCode.Boolean:
+					return new PrimitiveType("Boolean");
+				case TypeCode.Char:
+					return new PrimitiveType("Char");
+				case TypeCode.SByte:
+					return new PrimitiveType("SByte");
+				case TypeCode.Byte:
+					return new PrimitiveType("Byte");
+				case TypeCode.Int16:
+					return new PrimitiveType("Short");
+				case TypeCode.UInt16:
+					return new PrimitiveType("UShort");
+				case TypeCode.Int32:
+					return new PrimitiveType("Integer");
+				case TypeCode.UInt32:
+					return new PrimitiveType("UInteger");
+				case TypeCode.Int64:
+					return new PrimitiveType("Long");
+				case TypeCode.UInt64:
+					return new PrimitiveType("ULong");
+				case TypeCode.Single:
+					return new PrimitiveType("Single");
+				case TypeCode.Double:
+					return new PrimitiveType("Double");
+				case TypeCode.Decimal:
+					return new PrimitiveType("Decimal");
+				case TypeCode.String:
+					return new PrimitiveType("String");
+				case TypeCode.DateTime:
+					return new PrimitiveType("Date");
+			}
+			return new SimpleType(type.FullName); // TODO: implement this correctly
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/ComposedType.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/ComposedType.cs
new file mode 100644
index 000000000..e214a7e4b
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/ComposedType.cs
@@ -0,0 +1,119 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class ComposedType : AstType
+	{
+		public static readonly Role<VBTokenNode> NullableRole = new Role<VBTokenNode>("Nullable", VBTokenNode.Null);
+		public static readonly Role<ArraySpecifier> ArraySpecifierRole = new Role<ArraySpecifier>("ArraySpecifier");
+		
+		public AstType BaseType {
+			get { return GetChildByRole(Roles.Type); }
+			set { SetChildByRole(Roles.Type, value); }
+		}
+		
+		public bool HasNullableSpecifier {
+			get {
+				return !GetChildByRole(NullableRole).IsNull;
+			}
+			set {
+				SetChildByRole(NullableRole, value ? new VBTokenNode(AstLocation.Empty, 1) : null);
+			}
+		}
+		
+		public AstNodeCollection<ArraySpecifier> ArraySpecifiers {
+			get { return GetChildrenByRole (ArraySpecifierRole); }
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitComposedType (this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			ComposedType o = other as ComposedType;
+			return o != null && this.HasNullableSpecifier == o.HasNullableSpecifier && this.ArraySpecifiers.DoMatch(o.ArraySpecifiers, match);
+		}
+		
+		public override string ToString()
+		{
+			StringBuilder b = new StringBuilder();
+			b.Append(this.BaseType.ToString());
+			if (this.HasNullableSpecifier)
+				b.Append('?');
+			foreach (var arraySpecifier in this.ArraySpecifiers) {
+				b.Append('(');
+				b.Append(',', arraySpecifier.Dimensions - 1);
+				b.Append(')');
+			}
+			return b.ToString();
+		}
+		
+		public override AstType MakeArrayType(int dimensions)
+		{
+			InsertChildBefore(this.ArraySpecifiers.FirstOrDefault(), new ArraySpecifier(dimensions), ArraySpecifierRole);
+			return this;
+		}
+	}
+	
+	/// <summary>
+	/// [,,,]
+	/// </summary>
+	public class ArraySpecifier : AstNode
+	{
+		public ArraySpecifier()
+		{
+		}
+		
+		public ArraySpecifier(int dimensions)
+		{
+			this.Dimensions = dimensions;
+		}
+		
+		public VBTokenNode LParToken {
+			get { return GetChildByRole (Roles.LPar); }
+		}
+		
+		public int Dimensions {
+			get { return 1 + GetChildrenByRole(Roles.Comma).Count(); }
+			set {
+				int d = this.Dimensions;
+				while (d > value) {
+					GetChildByRole(Roles.Comma).Remove();
+					d--;
+				}
+				while (d < value) {
+					InsertChildBefore(GetChildByRole(Roles.Comma), new VBTokenNode(AstLocation.Empty, 1), Roles.Comma);
+					d++;
+				}
+			}
+		}
+		
+		public VBTokenNode RParToken {
+			get { return GetChildByRole (Roles.LPar); }
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitArraySpecifier(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			ArraySpecifier o = other as ArraySpecifier;
+			return o != null && this.Dimensions == o.Dimensions;
+		}
+		
+		public override string ToString()
+		{
+			return "(" + new string(',', this.Dimensions - 1) + ")";
+		}
+	}
+}
+
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/PrimitiveType.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/PrimitiveType.cs
new file mode 100644
index 000000000..8d6badc8f
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/PrimitiveType.cs
@@ -0,0 +1,57 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class PrimitiveType : AstType
+	{
+		public string Keyword { get; set; }
+		public AstLocation Location { get; set; }
+		
+		public PrimitiveType()
+		{
+		}
+		
+		public PrimitiveType(string keyword)
+		{
+			this.Keyword = keyword;
+		}
+		
+		public PrimitiveType(string keyword, AstLocation location)
+		{
+			this.Keyword = keyword;
+			this.Location = location;
+		}
+		
+		public override AstLocation StartLocation {
+			get {
+				return Location;
+			}
+		}
+		public override AstLocation EndLocation {
+			get {
+				return new AstLocation (Location.Line, Location.Column + (Keyword != null ? Keyword.Length : 0));
+			}
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitPrimitiveType(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			PrimitiveType o = other as PrimitiveType;
+			return o != null && MatchString(this.Keyword, o.Keyword);
+		}
+		
+		public override string ToString()
+		{
+			return Keyword ?? base.ToString();
+		}
+	}
+}
+
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/QualifiedType.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/QualifiedType.cs
new file mode 100644
index 000000000..2dbb28516
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/QualifiedType.cs
@@ -0,0 +1,66 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Linq;
+using System.Text;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Description of QualifiedType.
+	/// </summary>
+	public class QualifiedType : AstType
+	{
+		public static readonly Role<AstType> TargetRole = new Role<AstType>("Target", AstType.Null);
+		
+		public AstType Target {
+			get { return GetChildByRole(TargetRole); }
+			set { SetChildByRole(TargetRole, value); }
+		}
+		
+		public string Name {
+			get {
+				return GetChildByRole (Roles.Identifier).Name;
+			}
+			set {
+				SetChildByRole (Roles.Identifier, new Identifier(value, AstLocation.Empty));
+			}
+		}
+		
+		public QualifiedType(AstType target, Identifier name)
+		{
+			Target = target;
+			SetChildByRole(Roles.Identifier, name);
+		}
+		
+		public AstNodeCollection<AstType> TypeArguments {
+			get { return GetChildrenByRole (Roles.TypeArgument); }
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitQualifiedType(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			var o = other as QualifiedType;
+			return o != null && MatchString(this.Name, o.Name) && this.Target.DoMatch(o.Target, match);
+		}
+		
+		public override string ToString()
+		{
+			StringBuilder b = new StringBuilder();
+			b.Append(this.Target);
+			b.Append('.');
+			b.Append(this.Name);
+			if (this.TypeArguments.Any()) {
+				b.Append('(');
+				b.Append(string.Join(", ", this.TypeArguments));
+				b.Append(')');
+			}
+			return b.ToString();
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/SimpleType.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/SimpleType.cs
new file mode 100644
index 000000000..6ddc198d7
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeName/SimpleType.cs
@@ -0,0 +1,87 @@
+// 
+// FullTypeName.cs
+//
+// Author:
+//       Mike Krüger <mkrueger@novell.com>
+// 
+// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	public class SimpleType : AstType
+	{
+		public SimpleType()
+		{
+		}
+		
+		public SimpleType(string identifier)
+		{
+			this.Identifier = identifier;
+		}
+		
+		public SimpleType(string identifier, AstLocation location)
+		{
+			SetChildByRole (Roles.Identifier, new Identifier(identifier, location));
+		}
+		
+		public string Identifier {
+			get {
+				return GetChildByRole (Roles.Identifier).Name;
+			}
+			set {
+				SetChildByRole (Roles.Identifier, new Identifier(value, AstLocation.Empty));
+			}
+		}
+		
+		public AstNodeCollection<AstType> TypeArguments {
+			get { return GetChildrenByRole (Roles.TypeArgument); }
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitSimpleType(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			SimpleType o = other as SimpleType;
+			return o != null && MatchString(this.Identifier, o.Identifier) && this.TypeArguments.DoMatch(o.TypeArguments, match);
+		}
+		
+		public override string ToString()
+		{
+			StringBuilder b = new StringBuilder(this.Identifier);
+			if (this.TypeArguments.Any()) {
+				b.Append('(');
+				b.Append("Of ");
+				b.Append(string.Join(", ", this.TypeArguments));
+				b.Append(')');
+			}
+			return b.ToString();
+		}
+	}
+}
+
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeReference.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeReference.cs
deleted file mode 100644
index a0ab71390..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Ast/TypeReference.cs
+++ /dev/null
@@ -1,427 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Globalization;
-using System.Runtime.InteropServices;
-using System.Text;
-
-namespace ICSharpCode.NRefactory.VB.Ast
-{
-	public class TypeReference : AbstractNode, INullable, ICloneable
-	{
-		public static readonly TypeReference StructConstraint = new TypeReference("constraint: struct");
-		public static readonly TypeReference ClassConstraint = new TypeReference("constraint: class");
-		public static readonly TypeReference NewConstraint = new TypeReference("constraint: new");
-		
-		string type = "";
-		int    pointerNestingLevel;
-		int[]  rankSpecifier;
-		List<TypeReference> genericTypes = new List<TypeReference>();
-		
-		#region Static primitive type list
-		static Dictionary<string, string> types   = new Dictionary<string, string>();
-		static Dictionary<string, string> vbtypes = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
-		static Dictionary<string, string> typesReverse   = new Dictionary<string, string>();
-		static Dictionary<string, string> vbtypesReverse = new Dictionary<string, string>();
-		
-		static TypeReference()
-		{
-			// C# types
-			types.Add("bool",    "System.Boolean");
-			types.Add("byte",    "System.Byte");
-			types.Add("char",    "System.Char");
-			types.Add("decimal", "System.Decimal");
-			types.Add("double",  "System.Double");
-			types.Add("float",   "System.Single");
-			types.Add("int",     "System.Int32");
-			types.Add("long",    "System.Int64");
-			types.Add("object",  "System.Object");
-			types.Add("sbyte",   "System.SByte");
-			types.Add("short",   "System.Int16");
-			types.Add("string",  "System.String");
-			types.Add("uint",    "System.UInt32");
-			types.Add("ulong",   "System.UInt64");
-			types.Add("ushort",  "System.UInt16");
-			types.Add("void",    "System.Void");
-			
-			// VB.NET types
-			vbtypes.Add("Boolean", "System.Boolean");
-			vbtypes.Add("Byte",    "System.Byte");
-			vbtypes.Add("SByte",   "System.SByte");
-			vbtypes.Add("Date",	   "System.DateTime");
-			vbtypes.Add("Char",    "System.Char");
-			vbtypes.Add("Decimal", "System.Decimal");
-			vbtypes.Add("Double",  "System.Double");
-			vbtypes.Add("Single",  "System.Single");
-			vbtypes.Add("Integer", "System.Int32");
-			vbtypes.Add("Long",    "System.Int64");
-			vbtypes.Add("UInteger","System.UInt32");
-			vbtypes.Add("ULong",   "System.UInt64");
-			vbtypes.Add("Object",  "System.Object");
-			vbtypes.Add("Short",   "System.Int16");
-			vbtypes.Add("UShort",  "System.UInt16");
-			vbtypes.Add("String",  "System.String");
-			
-			foreach (KeyValuePair<string, string> pair in types) {
-				typesReverse.Add(pair.Value, pair.Key);
-			}
-			foreach (KeyValuePair<string, string> pair in vbtypes) {
-				vbtypesReverse.Add(pair.Value, pair.Key);
-			}
-		}
-		
-		/// <summary>
-		/// Gets a shortname=>full name dictionary of C# types.
-		/// </summary>
-		public static IDictionary<string, string> PrimitiveTypesCSharp {
-			get { return types; }
-		}
-		
-		/// <summary>
-		/// Gets a shortname=>full name dictionary of VB types.
-		/// </summary>
-		public static IDictionary<string, string> PrimitiveTypesVB {
-			get { return vbtypes; }
-		}
-		
-		/// <summary>
-		/// Gets a full name=>shortname dictionary of C# types.
-		/// </summary>
-		public static IDictionary<string, string> PrimitiveTypesCSharpReverse {
-			get { return typesReverse; }
-		}
-		
-		/// <summary>
-		/// Gets a full name=>shortname dictionary of VB types.
-		/// </summary>
-		public static IDictionary<string, string> PrimitiveTypesVBReverse {
-			get { return vbtypesReverse; }
-		}
-		
-		
-		static string GetSystemType(string type)
-		{
-			if (types == null) return type;
-			
-			string systemType;
-			if (types.TryGetValue(type, out systemType)) {
-				return systemType;
-			}
-			if (vbtypes.TryGetValue(type, out systemType)) {
-				return systemType;
-			}
-			return type;
-		}
-		#endregion
-		
-		object ICloneable.Clone()
-		{
-			return this.Clone();
-		}
-		
-		public virtual TypeReference Clone()
-		{
-			TypeReference c = new TypeReference(type);
-			CopyFields(this, c);
-			return c;
-		}
-		
-		/// <summary>
-		/// Copies the pointerNestingLevel, RankSpecifier, GenericTypes and IsGlobal flag
-		/// from <paramref name="from"/> to <paramref name="to"/>.
-		/// </summary>
-		/// <remarks>
-		/// If <paramref name="to"/> already contains generics, the new generics are appended to the list.
-		/// </remarks>
-		protected static void CopyFields(TypeReference from, TypeReference to)
-		{
-			to.pointerNestingLevel = from.pointerNestingLevel;
-			if (from.rankSpecifier != null) {
-				to.rankSpecifier = (int[])from.rankSpecifier.Clone();
-			}
-			foreach (TypeReference r in from.genericTypes) {
-				to.genericTypes.Add(r.Clone());
-			}
-			to.IsGlobal = from.IsGlobal;
-			to.IsKeyword = from.IsKeyword;
-		}
-		
-		public string Type {
-			get {
-				return type;
-			}
-			set {
-				Debug.Assert(value != null);
-				type = value ?? "?";
-			}
-		}
-		
-		/// <summary>
-		/// Removes the last identifier from the type.
-		/// e.g. "System.String.Length" becomes "System.String" or
-		/// "System.Collections.IEnumerable(of string).Current" becomes "System.Collections.IEnumerable(of string)"
-		/// This is used for explicit interface implementation in VB.
-		/// </summary>
-		public static string StripLastIdentifierFromType(ref TypeReference tr)
-		{
-			if (tr is InnerClassTypeReference && ((InnerClassTypeReference)tr).Type.IndexOf('.') < 0) {
-				string ident = ((InnerClassTypeReference)tr).Type;
-				tr = ((InnerClassTypeReference)tr).BaseType;
-				return ident;
-			} else {
-				int pos = tr.Type.LastIndexOf('.');
-				if (pos < 0)
-					return tr.Type;
-				string ident = tr.Type.Substring(pos + 1);
-				tr.Type = tr.Type.Substring(0, pos);
-				return ident;
-			}
-		}
-		
-		public int PointerNestingLevel {
-			get {
-				return pointerNestingLevel;
-			}
-			set {
-				Debug.Assert(this.IsNull == false);
-				pointerNestingLevel = value;
-			}
-		}
-		
-		/// <summary>
-		/// The rank of the array type.
-		/// For "object[]", this is { 0 }; for "object[,]", it is {1}.
-		/// For "object[,][,,][]", it is {1, 2, 0}.
-		/// For non-array types, this property is null or {}.
-		/// </summary>
-		public int[] RankSpecifier {
-			get {
-				return rankSpecifier;
-			}
-			set {
-				Debug.Assert(this.IsNull == false);
-				rankSpecifier = value;
-			}
-		}
-		
-		public List<TypeReference> GenericTypes {
-			get {
-				return genericTypes;
-			}
-		}
-		
-		public bool IsArrayType {
-			get {
-				return rankSpecifier != null && rankSpecifier.Length > 0;
-			}
-		}
-		
-		public static TypeReference CheckNull(TypeReference typeReference)
-		{
-			return typeReference ?? NullTypeReference.Instance;
-		}
-		
-		public static TypeReference Null {
-			get {
-				return NullTypeReference.Instance;
-			}
-		}
-		
-		public virtual bool IsNull {
-			get {
-				return false;
-			}
-		}
-		
-		/// <summary>
-		/// Gets/Sets if the type reference had a "global::" prefix.
-		/// </summary>
-		public bool IsGlobal {
-			get; set;
-		}
-		
-		/// <summary>
-		/// Gets/Sets if the type reference was using a language keyword.
-		/// </summary>
-		public bool IsKeyword {
-			get; set;
-		}
-		
-		public TypeReference(string type)
-		{
-			this.Type = type;
-		}
-		
-		public TypeReference(string type, bool isKeyword)
-		{
-			this.Type = type;
-			this.IsKeyword = isKeyword;
-		}
-		
-		public TypeReference(string type, List<TypeReference> genericTypes) : this(type)
-		{
-			if (genericTypes != null) {
-				this.genericTypes = genericTypes;
-			}
-		}
-		
-		public TypeReference(string type, int[] rankSpecifier) : this(type, 0, rankSpecifier)
-		{
-		}
-		
-		public TypeReference(string type, int pointerNestingLevel, int[] rankSpecifier) : this(type, pointerNestingLevel, rankSpecifier, null)
-		{
-		}
-		
-		public TypeReference(string type, int pointerNestingLevel, int[] rankSpecifier, List<TypeReference> genericTypes)
-		{
-			Debug.Assert(type != null);
-			this.type = type;
-			this.pointerNestingLevel = pointerNestingLevel;
-			this.rankSpecifier = rankSpecifier;
-			if (genericTypes != null) {
-				this.genericTypes = genericTypes;
-			}
-		}
-		
-		protected TypeReference()
-		{}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return visitor.VisitTypeReference(this, data);
-		}
-		
-		public override string ToString()
-		{
-			StringBuilder b = new StringBuilder(type);
-			if (genericTypes != null && genericTypes.Count > 0) {
-				b.Append('<');
-				for (int i = 0; i < genericTypes.Count; i++) {
-					if (i > 0) b.Append(',');
-					b.Append(genericTypes[i].ToString());
-				}
-				b.Append('>');
-			}
-			if (pointerNestingLevel > 0) {
-				b.Append('*', pointerNestingLevel);
-			}
-			if (IsArrayType) {
-				foreach (int rank in rankSpecifier) {
-					b.Append('[');
-					if (rank < 0)
-						b.Append('`', -rank);
-					else
-						b.Append(',', rank);
-					b.Append(']');
-				}
-			}
-			return b.ToString();
-		}
-		
-		public static bool AreEqualReferences(TypeReference a, TypeReference b)
-		{
-			if (a == b) return true;
-			if (a == null || b == null) return false;
-			if (a is InnerClassTypeReference) a = ((InnerClassTypeReference)a).CombineToNormalTypeReference();
-			if (b is InnerClassTypeReference) b = ((InnerClassTypeReference)b).CombineToNormalTypeReference();
-			if (a.type != b.type) return false;
-			if (a.IsKeyword != b.IsKeyword) return false;
-			if (a.IsGlobal != b.IsGlobal) return false;
-			if (a.pointerNestingLevel != b.pointerNestingLevel) return false;
-			if (a.IsArrayType != b.IsArrayType) return false;
-			if (a.IsArrayType) {
-				if (a.rankSpecifier.Length != b.rankSpecifier.Length) return false;
-				for (int i = 0; i < a.rankSpecifier.Length; i++) {
-					if (a.rankSpecifier[i] != b.rankSpecifier[i]) return false;
-				}
-			}
-			if (a.genericTypes.Count != b.genericTypes.Count) return false;
-			for (int i = 0; i < a.genericTypes.Count; i++) {
-				if (!AreEqualReferences(a.genericTypes[i], b.genericTypes[i]))
-					return false;
-			}
-			return true;
-		}
-	}
-
-	internal sealed class NullTypeReference : TypeReference
-	{
-		public static readonly NullTypeReference Instance = new NullTypeReference();
-		public override bool IsNull {
-			get {
-				return true;
-			}
-		}
-		public override TypeReference Clone()
-		{
-			return this;
-		}
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return null;
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[NullTypeReference]");
-		}
-	}
-
-	/// <summary>
-	/// We need this special type reference for cases like
-	/// OuterClass(Of T1).InnerClass(Of T2) (in expression or type context)
-	/// or Dictionary(Of String, NamespaceStruct).KeyCollection (in type context, otherwise it's a
-	/// MemberReferenceExpression)
-	/// </summary>
-	public class InnerClassTypeReference: TypeReference
-	{
-		TypeReference baseType;
-		
-		public TypeReference BaseType {
-			get { return baseType; }
-			set { baseType = value; }
-		}
-		
-		public override TypeReference Clone()
-		{
-			InnerClassTypeReference c = new InnerClassTypeReference(baseType.Clone(), Type, new List<TypeReference>());
-			CopyFields(this, c);
-			return c;
-		}
-		
-		public InnerClassTypeReference(TypeReference outerClass, string innerType, List<TypeReference> innerGenericTypes)
-			: base(innerType, innerGenericTypes)
-		{
-			this.baseType = outerClass;
-		}
-		
-		public override object AcceptVisitor(IAstVisitor visitor, object data)
-		{
-			return visitor.VisitInnerClassTypeReference(this, data);
-		}
-		
-		/// <summary>
-		/// Creates a type reference where all type parameters are specified for the innermost class.
-		/// Namespace.OuterClass(of string).InnerClass(of integer).InnerInnerClass
-		/// becomes Namespace.OuterClass.InnerClass.InnerInnerClass(of string, integer)
-		/// </summary>
-		public TypeReference CombineToNormalTypeReference()
-		{
-			TypeReference tr = (baseType is InnerClassTypeReference)
-				? ((InnerClassTypeReference)baseType).CombineToNormalTypeReference()
-				: baseType.Clone();
-			CopyFields(this, tr);
-			tr.Type += "." + Type;
-			return tr;
-		}
-		
-		public override string ToString()
-		{
-			return baseType.ToString() + "+" + base.ToString();
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/VBModifierToken.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/VBModifierToken.cs
new file mode 100644
index 000000000..05a22acc4
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/VBModifierToken.cs
@@ -0,0 +1,125 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Description of VBModifierToken.
+	/// </summary>
+	public class VBModifierToken : VBTokenNode
+	{
+		Modifiers modifier;
+		
+		public Modifiers Modifier {
+			get { return modifier; }
+			set {
+				for (int i = 0; i < lengthTable.Count; i++) {
+					if (lengthTable[i].Key == value) {
+						this.modifier = value;
+						this.tokenLength = lengthTable[i].Value;
+						return;
+					}
+				}
+				throw new ArgumentException ("Modifier " + value + " is invalid.");
+			}
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			VBModifierToken o = other as VBModifierToken;
+			return o != null && this.modifier == o.modifier;
+		}
+		
+		// Not worth using a dictionary for such few elements.
+		// This table is sorted in the order that modifiers should be output when generating code.
+		static readonly List<KeyValuePair<Modifiers, int>> lengthTable = new List<KeyValuePair<Modifiers, int>> () {
+			new KeyValuePair<Modifiers, int>(Modifiers.Public, "Public".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Protected, "Protected".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Private, "Private".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Friend, "Friend".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.MustInherit, "MustInherit".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.MustOverride, "MustOverride".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Overridable, "Overridable".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.NotInheritable, "NotInheritable".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.NotOverridable, "NotOverridable".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Const, "Const".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Shared, "Shared".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Static, "Static".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Override, "Override".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.ReadOnly, "ReadOnly".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.WriteOnly, "WriteOnly".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Shadows, "Shadows".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Partial, "Partial".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Overloads, "Overloads".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.WithEvents, "WithEvents".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Default, "Default".Length),
+			new KeyValuePair<Modifiers, int>(Modifiers.Dim, "Dim".Length),
+			
+			// even though it's used for patterns only, it needs to be in this table to be usable in the AST
+			new KeyValuePair<Modifiers, int>(Modifiers.Any, "Any".Length)
+		};
+		
+		public static IEnumerable<Modifiers> AllModifiers {
+			get { return lengthTable.Select(p => p.Key); }
+		}
+		
+		public VBModifierToken(AstLocation location, Modifiers modifier) : base (location, 0)
+		{
+			this.Modifier = modifier;
+		}
+		
+		public static string GetModifierName(Modifiers modifier)
+		{
+			switch (modifier) {
+				case Modifiers.Private:
+					return "Private";
+				case Modifiers.Friend:
+					return "Friend";
+				case Modifiers.Protected:
+					return "Protected";
+				case Modifiers.Public:
+					return "Public";
+				case Modifiers.MustInherit:
+					return "MustInherit";
+				case Modifiers.MustOverride:
+					return "MustOverride";
+				case Modifiers.Overridable:
+					return "Overridable";
+				case Modifiers.NotInheritable:
+					return "NotInheritable";
+				case Modifiers.NotOverridable:
+					return "NotOverridable";
+				case Modifiers.Const:
+					return "Const";
+				case Modifiers.Shared:
+					return "Shared";
+				case Modifiers.Static:
+					return "Static";
+				case Modifiers.Override:
+					return "Override";
+				case Modifiers.ReadOnly:
+					return "ReadOnly";
+				case Modifiers.Shadows:
+					return "Shadows";
+				case Modifiers.Partial:
+					return "Partial";
+				case Modifiers.Overloads:
+					return "Overloads";
+				case Modifiers.WithEvents:
+					return "WithEvents";
+				case Modifiers.Default:
+					return "Default";
+				case Modifiers.Dim:
+					return "Dim";
+				case Modifiers.WriteOnly:
+					return "WriteOnly";
+				default:
+					throw new NotSupportedException("Invalid value for Modifiers");
+			}
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Ast/VBTokenNode.cs b/NRefactory/ICSharpCode.NRefactory.VB/Ast/VBTokenNode.cs
new file mode 100644
index 000000000..225484e67
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Ast/VBTokenNode.cs
@@ -0,0 +1,87 @@
+/*
+ * Created by SharpDevelop.
+ * User: Siegfried
+ * Date: 11.04.2011
+ * Time: 20:44
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+
+namespace ICSharpCode.NRefactory.VB.Ast
+{
+	/// <summary>
+	/// Description of VBTokenNode.
+	/// </summary>
+	public class VBTokenNode : AstNode
+	{
+		public static new readonly VBTokenNode Null = new NullVBTokenNode();
+		
+		class NullVBTokenNode : VBTokenNode
+		{
+			public override bool IsNull {
+				get {
+					return true;
+				}
+			}
+			
+			public NullVBTokenNode() : base (AstLocation.Empty, 0)
+			{
+			}
+			
+			public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+			{
+				return default (S);
+			}
+			
+			protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+			{
+				return other == null || other.IsNull;
+			}
+		}
+		
+		AstLocation startLocation;
+		public override AstLocation StartLocation {
+			get {
+				return startLocation;
+			}
+		}
+		
+		protected int tokenLength = -1;
+		
+		AstLocation endLocation;
+		public override AstLocation EndLocation {
+			get {
+				return tokenLength < 0 ? endLocation : new AstLocation(startLocation.Line, startLocation.Column + tokenLength);
+			}
+		}
+		
+		public VBTokenNode(AstLocation location, int tokenLength)
+		{
+			this.startLocation = location;
+			this.tokenLength = tokenLength;
+		}
+		
+		public VBTokenNode(AstLocation startLocation, AstLocation endLocation)
+		{
+			this.startLocation = startLocation;
+			this.endLocation = endLocation;
+		}
+		
+		public override S AcceptVisitor<T, S> (IAstVisitor<T, S> visitor, T data)
+		{
+			return visitor.VisitVBTokenNode(this, data);
+		}
+		
+		protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
+		{
+			var node = other as VBTokenNode;
+			return node != null && !node.IsNull;
+		}
+		
+		public override string ToString ()
+		{
+			return string.Format ("[VBTokenNode: StartLocation={0}, EndLocation={1}, Role={2}]", StartLocation, EndLocation, Role);
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/ExpressionBuilder.cs b/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/ExpressionBuilder.cs
index c2992e19c..402dc449f 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/ExpressionBuilder.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/ExpressionBuilder.cs
@@ -11,10 +11,10 @@ namespace ICSharpCode.NRefactory.VB.AstBuilder
 	/// Extension methods for NRefactory.Dom.Expression.
 	/// </summary>
 	public static class ExpressionBuilder
-	{
-		public static IdentifierExpression Identifier(string identifier)
+	{/*
+		public static SimpleNameExpression Identifier(string identifier)
 		{
-			return new IdentifierExpression(identifier);
+			return new SimpleNameExpression(identifier);
 		}
 		
 		public static MemberReferenceExpression Member(this Expression targetObject, string memberName)
@@ -87,6 +87,6 @@ namespace ICSharpCode.NRefactory.VB.AstBuilder
 		public static BinaryOperatorExpression Operator(this Expression left, BinaryOperatorType op, Expression right)
 		{
 			return new BinaryOperatorExpression(left, op, right);
-		}
+		}*/
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/StatementBuilder.cs b/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/StatementBuilder.cs
index 807dfe8ab..1f3541f15 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/StatementBuilder.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/AstBuilder/StatementBuilder.cs
@@ -10,46 +10,46 @@ namespace ICSharpCode.NRefactory.VB.AstBuilder
 	/// <summary>
 	/// Extension methods for NRefactory.Dom.Expression.
 	/// </summary>
-	public static class StatementBuilder
-	{
-		public static void AddStatement(this BlockStatement block, Statement statement)
-		{
-			if (block == null)
-				throw new ArgumentNullException("block");
-			if (statement == null)
-				throw new ArgumentNullException("statement");
-			block.AddChild(statement);
-			statement.Parent = block;
-		}
-		
-		public static void AddStatement(this BlockStatement block, Expression expressionStatement)
-		{
-			if (expressionStatement == null)
-				throw new ArgumentNullException("expressionStatement");
-			AddStatement(block, new ExpressionStatement(expressionStatement));
-		}
-		
-		public static void Throw(this BlockStatement block, Expression expression)
-		{
-			if (expression == null)
-				throw new ArgumentNullException("expression");
-			AddStatement(block, new ThrowStatement(expression));
-		}
-		
-		public static void Return(this BlockStatement block, Expression expression)
-		{
-			if (expression == null)
-				throw new ArgumentNullException("expression");
-			AddStatement(block, new ReturnStatement(expression));
-		}
-		
-		public static void Assign(this BlockStatement block, Expression left, Expression right)
-		{
-			if (left == null)
-				throw new ArgumentNullException("left");
-			if (right == null)
-				throw new ArgumentNullException("right");
-			AddStatement(block, new AssignmentExpression(left, AssignmentOperatorType.Assign, right));
-		}
-	}
+//	public static class StatementBuilder
+//	{
+//		public static void AddStatement(this BlockStatement block, Statement statement)
+//		{
+//			if (block == null)
+//				throw new ArgumentNullException("block");
+//			if (statement == null)
+//				throw new ArgumentNullException("statement");
+//			block.AddChild(statement);
+//			statement.Parent = block;
+//		}
+//		
+//		public static void AddStatement(this BlockStatement block, Expression expressionStatement)
+//		{
+//			if (expressionStatement == null)
+//				throw new ArgumentNullException("expressionStatement");
+//			AddStatement(block, new ExpressionStatement(expressionStatement));
+//		}
+//		
+//		public static void Throw(this BlockStatement block, Expression expression)
+//		{
+//			if (expression == null)
+//				throw new ArgumentNullException("expression");
+//			AddStatement(block, new ThrowStatement(expression));
+//		}
+//		
+//		public static void Return(this BlockStatement block, Expression expression)
+//		{
+//			if (expression == null)
+//				throw new ArgumentNullException("expression");
+//			AddStatement(block, new ReturnStatement(expression));
+//		}
+//		
+//		public static void Assign(this BlockStatement block, Expression left, Expression right)
+//		{
+//			if (left == null)
+//				throw new ArgumentNullException("left");
+//			if (right == null)
+//				throw new ArgumentNullException("right");
+//			AddStatement(block, new AssignmentExpression(left, AssignmentOperatorType.Assign, right));
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/EnvironmentInformationProvider.cs b/NRefactory/ICSharpCode.NRefactory.VB/EnvironmentInformationProvider.cs
deleted file mode 100644
index df393e9dc..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/EnvironmentInformationProvider.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.NRefactory.VB
-{
-	public interface IEnvironmentInformationProvider
-	{
-		bool HasField(string reflectionTypeName, int typeParameterCount, string fieldName);
-	}
-	
-	sealed class DummyEnvironmentInformationProvider : IEnvironmentInformationProvider
-	{
-		internal static readonly IEnvironmentInformationProvider Instance = new DummyEnvironmentInformationProvider();
-		
-		public bool HasField(string reflectionTypeName, int typeParameterCount, string fieldName)
-		{
-			return false;
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs
index 5e81a2be0..a2f8ac6c7 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/IAstVisitor.cs
@@ -1,242 +1,46 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.1
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.VB.Ast;
+using Attribute = ICSharpCode.NRefactory.VB.Ast.Attribute;
 
 namespace ICSharpCode.NRefactory.VB {
-	using System;
-	using ICSharpCode.NRefactory.VB.Ast;
-	
-	
-	public interface IAstVisitor {
-		
-		object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data);
-		
-		object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data);
-		
-		object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data);
-		
-		object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data);
-		
-		object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data);
-		
-		object VisitAttributeSection(AttributeSection attributeSection, object data);
-		
-		object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data);
-		
-		object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data);
-		
-		object VisitBlockStatement(BlockStatement blockStatement, object data);
-		
-		object VisitCaseLabel(CaseLabel caseLabel, object data);
-		
-		object VisitCastExpression(CastExpression castExpression, object data);
-		
-		object VisitCatchClause(CatchClause catchClause, object data);
-		
-		object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data);
-		
-		object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data);
-		
-		object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data);
-		
-		object VisitCompilationUnit(CompilationUnit compilationUnit, object data);
-		
-		object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data);
-		
-		object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data);
-		
-		object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data);
-		
-		object VisitContinueStatement(ContinueStatement continueStatement, object data);
-		
-		object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data);
-		
-		object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data);
-		
-		object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data);
-		
-		object VisitDirectionExpression(DirectionExpression directionExpression, object data);
-		
-		object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data);
-		
-		object VisitElseIfSection(ElseIfSection elseIfSection, object data);
-		
-		object VisitEndStatement(EndStatement endStatement, object data);
-		
-		object VisitEraseStatement(EraseStatement eraseStatement, object data);
-		
-		object VisitErrorStatement(ErrorStatement errorStatement, object data);
-		
-		object VisitEventAddRegion(EventAddRegion eventAddRegion, object data);
-		
-		object VisitEventDeclaration(EventDeclaration eventDeclaration, object data);
-		
-		object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data);
-		
-		object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data);
-		
-		object VisitExitStatement(ExitStatement exitStatement, object data);
-		
-		object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data);
-		
-		object VisitExpressionStatement(ExpressionStatement expressionStatement, object data);
-		
-		object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data);
-		
-		object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data);
-		
-		object VisitForeachStatement(ForeachStatement foreachStatement, object data);
-		
-		object VisitForNextStatement(ForNextStatement forNextStatement, object data);
-		
-		object VisitGotoStatement(GotoStatement gotoStatement, object data);
-		
-		object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data);
-		
-		object VisitIfElseStatement(IfElseStatement ifElseStatement, object data);
-		
-		object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data);
-		
-		object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data);
-		
-		object VisitInvocationExpression(InvocationExpression invocationExpression, object data);
-		
-		object VisitLabelStatement(LabelStatement labelStatement, object data);
-		
-		object VisitLambdaExpression(LambdaExpression lambdaExpression, object data);
-		
-		object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data);
-		
-		object VisitLockStatement(LockStatement lockStatement, object data);
-		
-		object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data);
-		
-		object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data);
-		
-		object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data);
-		
-		object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data);
-		
-		object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data);
-		
-		object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data);
-		
-		object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data);
-		
-		object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data);
-		
-		object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data);
-		
-		object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data);
-		
-		object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data);
-		
-		object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data);
-		
-		object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data);
-		
-		object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data);
-		
-		object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data);
-		
-		object VisitQueryExpression(QueryExpression queryExpression, object data);
-		
-		object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data);
-		
-		object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data);
-		
-		object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data);
-		
-		object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data);
-		
-		object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data);
-		
-		object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data);
-		
-		object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data);
-		
-		object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data);
-		
-		object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data);
-		
-		object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data);
-		
-		object VisitQueryExpressionLetVBClause(QueryExpressionLetVBClause queryExpressionLetVBClause, object data);
-		
-		object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data);
-		
-		object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data);
-		
-		object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data);
-		
-		object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data);
-		
-		object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data);
-		
-		object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data);
-		
-		object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data);
-		
-		object VisitReDimStatement(ReDimStatement reDimStatement, object data);
-		
-		object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data);
-		
-		object VisitResumeStatement(ResumeStatement resumeStatement, object data);
-		
-		object VisitReturnStatement(ReturnStatement returnStatement, object data);
-		
-		object VisitStopStatement(StopStatement stopStatement, object data);
-		
-		object VisitSwitchSection(SwitchSection switchSection, object data);
-		
-		object VisitSwitchStatement(SwitchStatement switchStatement, object data);
-		
-		object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data);
-		
-		object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data);
-		
-		object VisitThrowStatement(ThrowStatement throwStatement, object data);
-		
-		object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data);
-		
-		object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data);
-		
-		object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data);
-		
-		object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data);
-		
-		object VisitTypeReference(TypeReference typeReference, object data);
-		
-		object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data);
-		
-		object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data);
-		
-		object VisitUsing(Using @using, object data);
-		
-		object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data);
-		
-		object VisitUsingStatement(UsingStatement usingStatement, object data);
-		
-		object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data);
-		
-		object VisitWithStatement(WithStatement withStatement, object data);
-		
-		object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data);
-		
-		object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data);
-		
-		object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data);
-		
-		object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data);
-		
-		object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data);
-		
-		object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data);
+	public interface IAstVisitor<in T, out S>
+	{
+		S VisitBlockStatement(BlockStatement blockStatement, T data);
+		S VisitCompilationUnit(CompilationUnit compilationUnit, T data);
+		S VisitPatternPlaceholder(AstNode placeholder, PatternMatching.Pattern pattern, T data);
+		S VisitTypeParameterDeclaration(TypeParameterDeclaration typeParameterDeclaration, T data);
+		S VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, T data);
+		S VisitVBTokenNode(VBTokenNode vBTokenNode, T data);
+		
+		// Global scope
+		S VisitAliasImportsClause(AliasImportsClause aliasImportsClause, T data);
+		S VisitAttribute(Attribute attribute, T data);
+		S VisitAttributeBlock(AttributeBlock attributeBlock, T data);
+		S VisitImportsStatement(ImportsStatement importsStatement, T data);
+		S VisitMembersImportsClause(MemberImportsClause membersImportsClause, T data);
+		S VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, T data);
+		S VisitOptionStatement(OptionStatement optionStatement, T data);
+		S VisitTypeDeclaration(TypeDeclaration typeDeclaration, T data);
+		S VisitXmlNamespaceImportsClause(XmlNamespaceImportsClause xmlNamespaceImportsClause, T data);
+		S VisitEnumDeclaration(EnumDeclaration enumDeclaration, T data);
+		S VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, T data);
+		S VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, T data);
+		
+		// Expression scope
+		S VisitIdentifier(Identifier identifier, T data);
+		S VisitXmlIdentifier(XmlIdentifier xmlIdentifier, T data);
+		S VisitXmlLiteralString(XmlLiteralString xmlLiteralString, T data);
+		S VisitSimpleNameExpression(SimpleNameExpression identifierExpression, T data);
+		S VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, T data);
+		
+		// TypeName
+		S VisitPrimitiveType(PrimitiveType primitiveType, T data);
+		S VisitQualifiedType(QualifiedType qualifiedType, T data);
+		S VisitComposedType(ComposedType composedType, T data);
+		S VisitArraySpecifier(ArraySpecifier arraySpecifier, T data);
+		S VisitSimpleType(SimpleType simpleType, T data);
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj b/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj
index b8cc68148..1dac9e1d9 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj
+++ b/NRefactory/ICSharpCode.NRefactory.VB/ICSharpCode.NRefactory.VB.csproj
@@ -43,19 +43,41 @@
   <ItemGroup>
     <Compile Include="AstBuilder\ExpressionBuilder.cs" />
     <Compile Include="AstBuilder\StatementBuilder.cs" />
-    <Compile Include="Ast\AbstractNode.cs" />
+    <Compile Include="Ast\AstLocation.cs" />
+    <Compile Include="Ast\AstNode.cs" />
+    <Compile Include="Ast\AstNodeCollection.cs" />
     <Compile Include="Ast\Enums.cs" />
-    <Compile Include="Ast\General\BlockStatement.cs" />
+    <Compile Include="Ast\Expressions\Expression.cs" />
+    <Compile Include="Ast\Expressions\SimpleNameExpression.cs" />
+    <Compile Include="Ast\Expressions\PrimitiveExpression.cs" />
+    <Compile Include="Ast\Expressions\XmlIdentifier.cs" />
+    <Compile Include="Ast\Expressions\XmlLiteralString.cs" />
+    <Compile Include="Ast\General\Attribute.cs" />
+    <Compile Include="Ast\General\AttributeBlock.cs" />
+    <Compile Include="Ast\General\AttributedNode.cs" />
     <Compile Include="Ast\General\CompilationUnit.cs" />
-    <Compile Include="Ast\General\Expression.cs" />
-    <Compile Include="Ast\General\LocalVariableDeclaration.cs" />
-    <Compile Include="Ast\General\PrimitiveExpression.cs" />
-    <Compile Include="Ast\General\Statement.cs" />
+    <Compile Include="Ast\General\ParameterDeclaration.cs" />
+    <Compile Include="Ast\General\TypeParameterDeclaration.cs" />
     <Compile Include="Ast\Generated.cs" />
-    <Compile Include="Ast\INode.cs" />
+    <Compile Include="Ast\GlobalScope\DelegateDeclaration.cs" />
+    <Compile Include="Ast\GlobalScope\EnumDeclaration.cs" />
+    <Compile Include="Ast\GlobalScope\EnumMemberDeclaration.cs" />
+    <Compile Include="Ast\GlobalScope\ImportsClause.cs" />
+    <Compile Include="Ast\GlobalScope\ImportsStatement.cs" />
+    <Compile Include="Ast\GlobalScope\NamespaceDeclaration.cs" />
+    <Compile Include="Ast\GlobalScope\TypeDeclaration.cs" />
+    <Compile Include="Ast\GlobalScope\OptionStatement.cs" />
+    <Compile Include="Ast\Identifier.cs" />
     <Compile Include="Ast\INullable.cs" />
-    <Compile Include="Ast\TypeReference.cs" />
-    <Compile Include="EnvironmentInformationProvider.cs" />
+    <Compile Include="Ast\Statements\BlockStatement.cs" />
+    <Compile Include="Ast\Statements\Statement.cs" />
+    <Compile Include="Ast\TypeName\AstType.cs" />
+    <Compile Include="Ast\TypeName\ComposedType.cs" />
+    <Compile Include="Ast\TypeName\PrimitiveType.cs" />
+    <Compile Include="Ast\TypeName\QualifiedType.cs" />
+    <Compile Include="Ast\TypeName\SimpleType.cs" />
+    <Compile Include="Ast\VBModifierToken.cs" />
+    <Compile Include="Ast\VBTokenNode.cs" />
     <Compile Include="IAstVisitor.cs" />
     <Compile Include="Lexer\Block.cs" />
     <Compile Include="Lexer\ExpressionFinder.cs" />
@@ -80,12 +102,11 @@
     <Compile Include="Lexer\Tokens.cs" />
     <Compile Include="Lexer\VBLexerMemento.cs" />
     <Compile Include="Lexer\XmlModeInfo.cs" />
-    <Compile Include="Location.cs" />
-    <Compile Include="OperatorPrecedence.cs" />
-    <Compile Include="ParserFactory.cs" />
+    <Compile Include="OutputVisitor\IOutputFormatter.cs" />
+    <Compile Include="OutputVisitor\OutputVisitor.cs" />
+    <Compile Include="OutputVisitor\TextWriterOutputFormatter.cs" />
+    <Compile Include="OutputVisitor\VBFormattingOptions.cs" />
     <Compile Include="Parser\Errors.cs" />
-    <Compile Include="Parser\ModifierList.cs" />
-    <Compile Include="Parser\ParamModifierList.cs" />
     <Compile Include="Parser\Parser.cs">
       <DependentUpon>vb.atg</DependentUpon>
     </Compile>
@@ -98,25 +119,22 @@
     <Compile Include="PrettyPrinter\VBNet\VBNetOutputVisitor.cs" />
     <Compile Include="PrettyPrinter\VBNet\VBNetPrettyPrintOptions.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="SnippetParser.cs" />
+    <Compile Include="VBParser.cs" />
     <Compile Include="Visitors\AbstractAstTransformer.cs" />
     <Compile Include="Visitors\AbstractAstVisitor.cs" />
-    <Compile Include="Visitors\CodeDOMOutputVisitor.cs" />
-    <Compile Include="Visitors\CodeDOMVerboseOutputGenerator.cs" />
-    <Compile Include="Visitors\LookupTableVisitor.cs" />
     <Compile Include="Visitors\NodeTrackingAstVisitor.cs" />
-    <Compile Include="Visitors\NotImplementedAstVisitor.cs" />
-    <Compile Include="Visitors\PrefixFieldsVisitor.cs" />
-    <Compile Include="Visitors\RenameIdentifierVisitor.cs" />
-    <Compile Include="Visitors\SetParentVisitor.cs" />
-    <Compile Include="Visitors\SetRegionInclusionVisitor.cs" />
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Ast" />
     <Folder Include="AstBuilder" />
     <Folder Include="Ast\General" />
+    <Folder Include="Ast\GlobalScope" />
+    <Folder Include="Ast\Expressions" />
+    <Folder Include="Ast\Statements" />
+    <Folder Include="Ast\TypeName" />
     <Folder Include="Lexer" />
     <Folder Include="Lexer\Special" />
+    <Folder Include="OutputVisitor" />
     <Folder Include="Parser" />
     <Folder Include="PrettyPrinter" />
     <Folder Include="PrettyPrinter\VBNet" />
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Block.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Block.cs
index f7c104fce..c9ffba0d2 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Block.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Block.cs
@@ -33,11 +33,11 @@ namespace ICSharpCode.NRefactory.VB.Parser
 	{
 		public static readonly Block Default = new Block() {
 			context = Context.Global,
-			lastExpressionStart = Location.Empty
+			lastExpressionStart = AstLocation.Empty
 		};
 		
 		public Context context;
-		public Location lastExpressionStart;
+		public AstLocation lastExpressionStart;
 		public bool isClosed;
 		
 		public override string ToString()
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.atg b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.atg
index b0961d47f..b2768890d 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.atg
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.atg
@@ -281,6 +281,13 @@ ImportsStatement =
 		( "Global" | Identifier | PrimitiveTypeName ) { TypeSuffix } [ ( "." | "=" ) TypeName ]
 		| XmlOpenTag Identifier "=" LiteralString XmlCloseTag
 	)
+	{ ","
+		(. nextTokenIsStartOfImportsOrAccessExpression = true;	.)
+		(
+			( "Global" | Identifier | PrimitiveTypeName ) { TypeSuffix } [ ( "." | "=" ) TypeName ]
+			| XmlOpenTag Identifier "=" LiteralString XmlCloseTag
+		)
+	}
 	(. PopContext(); .)
 	StatementTerminator
 
@@ -512,6 +519,7 @@ Parameter =
 	(. PushContext(Context.Parameter, la, t); .)
 	{ AttributeBlock } { ParameterModifier }
 	(. PushContext(Context.Identifier, la, t); .) (.OnEachPossiblePath: SetIdentifierExpected(la); .) Identifier (. PopContext(); .)
+	[ "?" ] { "(" { "," } ")" }
 	[ "As" (. PushContext(Context.Type, la, t); .) TypeName (. PopContext(); .) ]
 	[ "=" Expression ]
 	(. PopContext(); .)
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.cs
index 9e5feef6e..15b9bdd6d 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/ExpressionFinder.cs
@@ -28,7 +28,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		void PushContext(Context context, Token la, Token t)
 		{
 			string indent = new string('\t', stack.Count);
-			Location l = la == null ? (t == null ? Location.Empty : t.EndLocation) : la.Location;
+			AstLocation l = la == null ? (t == null ? AstLocation.Empty : t.EndLocation) : la.Location;
 			
 			stack.Push(new Block() { context = context, lastExpressionStart = l });
 			Print(indent + "enter " + context);
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Parser.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Parser.cs
index 400c9a0f3..9fd64e952 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Parser.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Parser.cs
@@ -27,7 +27,7 @@ partial class ExpressionFinder {
 			case 6:
 			case 88:
 			case 264:
-			case 528:
+			case 530:
 				{
 					BitArray a = new BitArray(239);
 					return a;
@@ -53,22 +53,22 @@ partial class ExpressionFinder {
 			case 295:
 			case 399:
 			case 405:
-			case 472:
-			case 518:
-			case 525:
-			case 533:
-			case 563:
-			case 599:
-			case 648:
-			case 662:
-			case 735:
+			case 474:
+			case 520:
+			case 527:
+			case 535:
+			case 565:
+			case 601:
+			case 650:
+			case 664:
+			case 743:
 				return set[6];
 			case 12:
 			case 13:
-			case 564:
-			case 565:
-			case 610:
-			case 620:
+			case 566:
+			case 567:
+			case 612:
+			case 622:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(1, true);
@@ -96,27 +96,26 @@ partial class ExpressionFinder {
 			case 373:
 			case 396:
 			case 423:
-			case 524:
-			case 530:
-			case 536:
-			case 540:
-			case 548:
-			case 556:
-			case 566:
-			case 575:
-			case 592:
-			case 597:
-			case 605:
-			case 611:
-			case 614:
-			case 621:
-			case 624:
-			case 643:
-			case 646:
-			case 670:
-			case 678:
-			case 714:
-			case 734:
+			case 526:
+			case 532:
+			case 538:
+			case 542:
+			case 550:
+			case 558:
+			case 568:
+			case 577:
+			case 594:
+			case 599:
+			case 607:
+			case 613:
+			case 616:
+			case 623:
+			case 626:
+			case 645:
+			case 648:
+			case 672:
+			case 680:
+			case 716:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(1, true);
@@ -135,22 +134,22 @@ partial class ExpressionFinder {
 			case 298:
 			case 352:
 			case 397:
-			case 452:
-			case 573:
-			case 593:
-			case 612:
-			case 616:
-			case 622:
-			case 644:
-			case 679:
+			case 454:
+			case 575:
+			case 595:
+			case 614:
+			case 618:
+			case 624:
+			case 646:
+			case 681:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(113, true);
 					return a;
 				}
 			case 22:
-			case 541:
-			case 576:
+			case 543:
+			case 578:
 				return set[9];
 			case 25:
 				{
@@ -162,7 +161,7 @@ partial class ExpressionFinder {
 			case 27:
 				return set[10];
 			case 28:
-			case 718:
+			case 720:
 				return set[11];
 			case 29:
 				return set[12];
@@ -176,30 +175,30 @@ partial class ExpressionFinder {
 			case 265:
 			case 276:
 			case 277:
-			case 442:
-			case 443:
-			case 460:
-			case 461:
+			case 444:
+			case 445:
 			case 462:
 			case 463:
-			case 551:
-			case 552:
-			case 585:
-			case 586:
-			case 673:
-			case 674:
-			case 727:
-			case 728:
+			case 464:
+			case 465:
+			case 553:
+			case 554:
+			case 587:
+			case 588:
+			case 675:
+			case 676:
+			case 729:
+			case 730:
 				return set[14];
 			case 33:
 			case 34:
-			case 519:
-			case 520:
-			case 526:
-			case 527:
-			case 553:
-			case 554:
-			case 667:
+			case 521:
+			case 522:
+			case 528:
+			case 529:
+			case 555:
+			case 556:
+			case 669:
 				return set[15];
 			case 35:
 			case 37:
@@ -212,25 +211,25 @@ partial class ExpressionFinder {
 			case 307:
 			case 332:
 			case 422:
-			case 439:
-			case 475:
-			case 529:
-			case 547:
-			case 555:
-			case 627:
-			case 630:
-			case 652:
-			case 655:
+			case 440:
+			case 477:
+			case 531:
+			case 549:
+			case 557:
+			case 629:
+			case 632:
+			case 654:
 			case 657:
-			case 669:
-			case 682:
+			case 659:
+			case 671:
 			case 684:
-			case 707:
-			case 710:
-			case 713:
-			case 719:
-			case 722:
-			case 740:
+			case 686:
+			case 709:
+			case 712:
+			case 715:
+			case 721:
+			case 724:
+			case 742:
 				return set[16];
 			case 38:
 			case 41:
@@ -242,7 +241,7 @@ partial class ExpressionFinder {
 			case 101:
 			case 163:
 			case 388:
-			case 479:
+			case 481:
 				return set[19];
 			case 42:
 			case 177:
@@ -250,12 +249,12 @@ partial class ExpressionFinder {
 			case 189:
 			case 253:
 			case 424:
-			case 449:
-			case 471:
-			case 474:
-			case 587:
-			case 588:
-			case 640:
+			case 451:
+			case 473:
+			case 476:
+			case 589:
+			case 590:
+			case 642:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(37, true);
@@ -272,15 +271,15 @@ partial class ExpressionFinder {
 			case 188:
 			case 392:
 			case 427:
-			case 473:
-			case 476:
-			case 496:
-			case 559:
-			case 590:
-			case 642:
-			case 688:
-			case 717:
-			case 726:
+			case 475:
+			case 478:
+			case 498:
+			case 561:
+			case 592:
+			case 644:
+			case 690:
+			case 719:
+			case 728:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(38, true);
@@ -308,10 +307,10 @@ partial class ExpressionFinder {
 			case 413:
 			case 419:
 			case 420:
-			case 487:
-			case 488:
-			case 701:
-			case 702:
+			case 489:
+			case 490:
+			case 703:
+			case 704:
 				return set[22];
 			case 53:
 			case 169:
@@ -321,16 +320,17 @@ partial class ExpressionFinder {
 			case 414:
 			case 421:
 			case 429:
-			case 437:
-			case 483:
-			case 486:
-			case 490:
+			case 438:
+			case 442:
+			case 485:
+			case 488:
 			case 492:
-			case 493:
-			case 503:
-			case 510:
-			case 517:
-			case 703:
+			case 494:
+			case 495:
+			case 505:
+			case 512:
+			case 519:
+			case 705:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(22, true);
@@ -374,14 +374,14 @@ partial class ExpressionFinder {
 			case 393:
 			case 395:
 			case 415:
-			case 438:
-			case 465:
-			case 481:
-			case 482:
+			case 439:
+			case 467:
+			case 483:
 			case 484:
-			case 485:
-			case 546:
-			case 626:
+			case 486:
+			case 487:
+			case 548:
+			case 628:
 				return set[23];
 			case 57:
 			case 78:
@@ -457,7 +457,7 @@ partial class ExpressionFinder {
 					return a;
 				}
 			case 71:
-			case 441:
+			case 443:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(40, true);
@@ -476,7 +476,7 @@ partial class ExpressionFinder {
 			case 282:
 			case 283:
 			case 334:
-			case 736:
+			case 744:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(20, true);
@@ -508,7 +508,7 @@ partial class ExpressionFinder {
 				}
 			case 84:
 			case 100:
-			case 513:
+			case 515:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(22, true);
@@ -555,7 +555,7 @@ partial class ExpressionFinder {
 					return a;
 				}
 			case 96:
-			case 683:
+			case 685:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(26, true);
@@ -612,7 +612,7 @@ partial class ExpressionFinder {
 					return a;
 				}
 			case 111:
-			case 453:
+			case 455:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(210, true);
@@ -644,8 +644,8 @@ partial class ExpressionFinder {
 					return a;
 				}
 			case 116:
-			case 598:
-			case 617:
+			case 600:
+			case 619:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(186, true);
@@ -766,7 +766,7 @@ partial class ExpressionFinder {
 					return a;
 				}
 			case 135:
-			case 635:
+			case 637:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(98, true);
@@ -845,8 +845,8 @@ partial class ExpressionFinder {
 				return set[32];
 			case 161:
 			case 162:
-			case 477:
-			case 478:
+			case 479:
+			case 480:
 				return set[33];
 			case 164:
 				return set[34];
@@ -856,7 +856,7 @@ partial class ExpressionFinder {
 			case 328:
 				return set[35];
 			case 175:
-			case 455:
+			case 457:
 				return set[36];
 			case 176:
 			case 375:
@@ -965,10 +965,10 @@ partial class ExpressionFinder {
 			case 245:
 				return set[45];
 			case 252:
-			case 550:
-			case 661:
-			case 672:
-			case 680:
+			case 552:
+			case 663:
+			case 674:
+			case 682:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(127, true);
@@ -992,16 +992,17 @@ partial class ExpressionFinder {
 			case 270:
 			case 275:
 			case 365:
-			case 653:
-			case 654:
+			case 655:
 			case 656:
-			case 691:
-			case 708:
-			case 709:
+			case 658:
+			case 693:
+			case 710:
 			case 711:
-			case 720:
-			case 721:
+			case 713:
+			case 722:
 			case 723:
+			case 725:
+			case 737:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(1, true);
@@ -1175,8 +1176,8 @@ partial class ExpressionFinder {
 				}
 			case 379:
 			case 380:
-			case 450:
-			case 451:
+			case 452:
+			case 453:
 				return set[69];
 			case 383:
 			case 384:
@@ -1208,8 +1209,8 @@ partial class ExpressionFinder {
 			case 410:
 			case 416:
 			case 417:
-			case 698:
-			case 699:
+			case 700:
+			case 701:
 				return set[75];
 			case 425:
 			case 426:
@@ -1217,8 +1218,8 @@ partial class ExpressionFinder {
 			case 428:
 			case 430:
 			case 431:
-			case 589:
-			case 641:
+			case 591:
+			case 643:
 				return set[77];
 			case 432:
 			case 433:
@@ -1227,7 +1228,9 @@ partial class ExpressionFinder {
 			case 435:
 				return set[79];
 			case 436:
-			case 440:
+				return set[80];
+			case 437:
+			case 441:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(20, true);
@@ -1235,79 +1238,80 @@ partial class ExpressionFinder {
 					a.Set(38, true);
 					return a;
 				}
-			case 444:
-			case 448:
-				return set[80];
-			case 445:
 			case 446:
+			case 450:
 				return set[81];
 			case 447:
+			case 448:
+				return set[82];
+			case 449:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(21, true);
 					return a;
 				}
-			case 454:
-				return set[82];
 			case 456:
-			case 469:
 				return set[83];
-			case 457:
-			case 470:
-				return set[84];
 			case 458:
+			case 471:
+				return set[84];
 			case 459:
+			case 472:
+				return set[85];
+			case 460:
+			case 461:
+			case 736:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(10, true);
 					return a;
 				}
-			case 464:
+			case 466:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(12, true);
 					return a;
 				}
-			case 466:
+			case 468:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(13, true);
 					return a;
 				}
-			case 467:
-				return set[85];
-			case 468:
+			case 469:
 				return set[86];
-			case 480:
+			case 470:
 				return set[87];
-			case 489:
-			case 491:
+			case 482:
 				return set[88];
-			case 494:
-			case 495:
-			case 557:
-			case 558:
-			case 686:
-			case 687:
+			case 491:
+			case 493:
 				return set[89];
+			case 496:
 			case 497:
-			case 498:
-			case 499:
-			case 504:
-			case 505:
+			case 559:
 			case 560:
+			case 688:
 			case 689:
-			case 716:
-			case 725:
 				return set[90];
+			case 499:
 			case 500:
+			case 501:
 			case 506:
-			case 515:
+			case 507:
+			case 562:
+			case 691:
+			case 718:
+			case 727:
 				return set[91];
-			case 501:
 			case 502:
-			case 507:
 			case 508:
+			case 517:
+				return set[92];
+			case 503:
+			case 504:
+			case 509:
+			case 510:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(22, true);
@@ -1315,18 +1319,18 @@ partial class ExpressionFinder {
 					a.Set(63, true);
 					return a;
 				}
-			case 509:
 			case 511:
-			case 516:
-				return set[92];
-			case 512:
-			case 514:
+			case 513:
+			case 518:
 				return set[93];
-			case 521:
-			case 534:
-			case 535:
-			case 591:
-			case 668:
+			case 514:
+			case 516:
+				return set[94];
+			case 523:
+			case 536:
+			case 537:
+			case 593:
+			case 670:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(1, true);
@@ -1334,28 +1338,28 @@ partial class ExpressionFinder {
 					a.Set(63, true);
 					return a;
 				}
-			case 522:
-			case 523:
-			case 595:
-			case 596:
-				return set[94];
-			case 531:
-			case 532:
-			case 539:
+			case 524:
+			case 525:
+			case 597:
+			case 598:
+				return set[95];
+			case 533:
+			case 534:
+			case 541:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(115, true);
 					return a;
 				}
-			case 537:
-			case 538:
-				return set[95];
-			case 542:
-			case 543:
+			case 539:
+			case 540:
 				return set[96];
 			case 544:
 			case 545:
-			case 604:
+				return set[97];
+			case 546:
+			case 547:
+			case 606:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(1, true);
@@ -1363,15 +1367,15 @@ partial class ExpressionFinder {
 					a.Set(21, true);
 					return a;
 				}
-			case 549:
+			case 551:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(103, true);
 					return a;
 				}
-			case 561:
-			case 562:
-			case 574:
+			case 563:
+			case 564:
+			case 576:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(84, true);
@@ -1379,84 +1383,84 @@ partial class ExpressionFinder {
 					a.Set(209, true);
 					return a;
 				}
-			case 567:
-			case 568:
-				return set[97];
 			case 569:
 			case 570:
 				return set[98];
 			case 571:
 			case 572:
-			case 583:
 				return set[99];
-			case 577:
-			case 578:
+			case 573:
+			case 574:
+			case 585:
 				return set[100];
 			case 579:
 			case 580:
-			case 705:
 				return set[101];
 			case 581:
-				return set[102];
 			case 582:
+			case 707:
+				return set[102];
+			case 583:
 				return set[103];
 			case 584:
-			case 594:
+				return set[104];
+			case 586:
+			case 596:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(172, true);
 					return a;
 				}
-			case 600:
-			case 601:
-				return set[104];
 			case 602:
-				return set[105];
 			case 603:
-			case 634:
+				return set[105];
+			case 604:
 				return set[106];
-			case 606:
-			case 607:
-			case 608:
-			case 625:
+			case 605:
+			case 636:
 				return set[107];
+			case 608:
 			case 609:
-			case 613:
-			case 623:
+			case 610:
+			case 627:
+				return set[108];
+			case 611:
+			case 615:
+			case 625:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(128, true);
 					a.Set(198, true);
 					return a;
 				}
-			case 615:
-				return set[108];
-			case 618:
+			case 617:
 				return set[109];
-			case 619:
+			case 620:
 				return set[110];
-			case 628:
-			case 629:
-			case 631:
-			case 697:
-			case 700:
+			case 621:
 				return set[111];
-			case 632:
+			case 630:
+			case 631:
 			case 633:
+			case 699:
+			case 702:
 				return set[112];
-			case 636:
+			case 634:
+			case 635:
+				return set[113];
 			case 638:
-			case 647:
+			case 640:
+			case 649:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(119, true);
 					return a;
 				}
-			case 637:
-				return set[113];
 			case 639:
 				return set[114];
-			case 645:
+			case 641:
+				return set[115];
+			case 647:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(56, true);
@@ -1464,11 +1468,11 @@ partial class ExpressionFinder {
 					a.Set(193, true);
 					return a;
 				}
-			case 649:
-			case 650:
-				return set[115];
 			case 651:
-			case 658:
+			case 652:
+				return set[116];
+			case 653:
+			case 660:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(1, true);
@@ -1476,111 +1480,116 @@ partial class ExpressionFinder {
 					a.Set(136, true);
 					return a;
 				}
-			case 659:
+			case 661:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(101, true);
 					return a;
 				}
-			case 660:
-				return set[116];
-			case 663:
-			case 664:
+			case 662:
+				return set[117];
+			case 665:
+			case 666:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(149, true);
 					return a;
 				}
-			case 665:
-			case 671:
-			case 737:
-				{
+			case 667:
+			case 673:
+			case 745:
+				{
 					BitArray a = new BitArray(239);
 					a.Set(3, true);
 					return a;
 				}
-			case 666:
-				return set[117];
-			case 675:
-			case 676:
+			case 668:
 				return set[118];
 			case 677:
-			case 685:
+			case 678:
 				return set[119];
-			case 681:
+			case 679:
+			case 687:
 				return set[120];
-			case 690:
-			case 692:
+			case 683:
 				return set[121];
-			case 693:
-			case 704:
-				return set[122];
+			case 692:
 			case 694:
+				return set[122];
 			case 695:
+			case 706:
 				return set[123];
 			case 696:
+			case 697:
 				return set[124];
-			case 706:
+			case 698:
+				return set[125];
+			case 708:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(136, true);
 					return a;
 				}
-			case 712:
+			case 714:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(140, true);
 					return a;
 				}
-			case 715:
-			case 724:
+			case 717:
+			case 726:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(169, true);
 					return a;
 				}
-			case 729:
-				return set[125];
-			case 730:
+			case 731:
+				return set[126];
+			case 732:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(160, true);
 					return a;
 				}
-			case 731:
+			case 733:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(137, true);
 					return a;
 				}
-			case 732:
-			case 733:
-				return set[126];
+			case 734:
+			case 735:
 			case 738:
+			case 739:
+				return set[127];
+			case 740:
+			case 747:
+				return set[128];
+			case 741:
+				return set[129];
+			case 746:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(11, true);
 					return a;
 				}
-			case 739:
-				return set[127];
-			case 741:
+			case 748:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(173, true);
 					return a;
 				}
-			case 742:
-				return set[128];
-			case 743:
+			case 749:
+				return set[130];
+			case 750:
 				{
 					BitArray a = new BitArray(239);
 					a.Set(67, true);
 					a.Set(213, true);
 					return a;
 				}
-			case 744:
-				return set[129];
+			case 751:
+				return set[131];
 			default: throw new InvalidOperationException();
 		}
 	}
@@ -1636,7 +1645,7 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 1; break; }
 				if (la.kind == 173) {
 					stateStack.Push(1);
-					goto case 741;
+					goto case 748;
 				} else {
 					goto case 2;
 				}
@@ -1645,7 +1654,7 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 2; break; }
 				if (la.kind == 137) {
 					stateStack.Push(2);
-					goto case 731;
+					goto case 733;
 				} else {
 					goto case 3;
 				}
@@ -1654,7 +1663,7 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 3; break; }
 				if (la.kind == 40) {
 					stateStack.Push(3);
-					goto case 441;
+					goto case 443;
 				} else {
 					goto case 4;
 				}
@@ -1673,7 +1682,7 @@ partial class ExpressionFinder {
 			case 5: {
 				if (la == null) { currentState = 5; break; }
 				if (la.kind == 160) {
-					currentState = 727;
+					currentState = 729;
 					break;
 				} else {
 					if (set[4].Get(la.kind)) {
@@ -1692,26 +1701,26 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 7; break; }
 				if (la.kind == 40) {
 					stateStack.Push(7);
-					goto case 441;
+					goto case 443;
 				} else {
 					goto case 8;
 				}
 			}
 			case 8: {
 				if (la == null) { currentState = 8; break; }
-				if (set[130].Get(la.kind)) {
+				if (set[132].Get(la.kind)) {
 					currentState = 8;
 					break;
 				} else {
 					if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
-						goto case 561;
+						goto case 563;
 					} else {
 						if (la.kind == 103) {
-							currentState = 550;
+							currentState = 552;
 							break;
 						} else {
 							if (la.kind == 115) {
-								goto case 531;
+								goto case 533;
 							} else {
 								if (la.kind == 142) {
 									goto case 9;
@@ -1746,7 +1755,7 @@ partial class ExpressionFinder {
 			case 13: {
 				if (la == null) { currentState = 13; break; }
 				if (la.kind == 37) {
-					currentState = 724;
+					currentState = 726;
 					break;
 				} else {
 					goto case 14;
@@ -1763,7 +1772,7 @@ partial class ExpressionFinder {
 			case 16: {
 				if (la == null) { currentState = 16; break; }
 				if (la.kind == 140) {
-					currentState = 719;
+					currentState = 721;
 					break;
 				} else {
 					goto case 17;
@@ -1833,7 +1842,7 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 27; break; }
 				if (la.kind == 40) {
 					stateStack.Push(26);
-					goto case 441;
+					goto case 443;
 				} else {
 					isMissingModifier = true;
 					goto case 28;
@@ -1841,8 +1850,8 @@ partial class ExpressionFinder {
 			}
 			case 28: {
 				if (la == null) { currentState = 28; break; }
-				if (set[131].Get(la.kind)) {
-					currentState = 718;
+				if (set[133].Get(la.kind)) {
+					currentState = 720;
 					break;
 				} else {
 					isMissingModifier = false;
@@ -1853,15 +1862,15 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 29; break; }
 				if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
 					stateStack.Push(17);
-					goto case 561;
+					goto case 563;
 				} else {
 					if (la.kind == 103) {
 						stateStack.Push(17);
-						goto case 549;
+						goto case 551;
 					} else {
 						if (la.kind == 115) {
 							stateStack.Push(17);
-							goto case 531;
+							goto case 533;
 						} else {
 							if (la.kind == 142) {
 								stateStack.Push(17);
@@ -1882,11 +1891,11 @@ partial class ExpressionFinder {
 			case 30: {
 				if (la == null) { currentState = 30; break; }
 				if (la.kind == 119) {
-					currentState = 525;
+					currentState = 527;
 					break;
 				} else {
 					if (la.kind == 186) {
-						currentState = 518;
+						currentState = 520;
 						break;
 					} else {
 						if (la.kind == 127 || la.kind == 210) {
@@ -1915,7 +1924,7 @@ partial class ExpressionFinder {
 			case 34: {
 				if (la == null) { currentState = 34; break; }
 				if (la.kind == 37) {
-					currentState = 494;
+					currentState = 496;
 					break;
 				} else {
 					if (la.kind == 63) {
@@ -1945,7 +1954,7 @@ partial class ExpressionFinder {
 						currentState = 38;
 						break;
 					} else {
-						if (set[132].Get(la.kind)) {
+						if (set[134].Get(la.kind)) {
 							currentState = 38;
 							break;
 						} else {
@@ -2006,7 +2015,7 @@ partial class ExpressionFinder {
 			case 44: {
 				if (la == null) { currentState = 44; break; }
 				if (la.kind == 169) {
-					currentState = 489;
+					currentState = 491;
 					break;
 				} else {
 					if (set[22].Get(la.kind)) {
@@ -2040,7 +2049,7 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 48; break; }
 				if (set[23].Get(la.kind)) {
 					activeArgument = 0;
-					goto case 485;
+					goto case 487;
 				} else {
 					if (la.kind == 22) {
 						activeArgument = 0;
@@ -2360,7 +2369,7 @@ partial class ExpressionFinder {
 			}
 			case 77: {
 				if (la == null) { currentState = 77; break; }
-				if (set[133].Get(la.kind)) {
+				if (set[135].Get(la.kind)) {
 					currentState = 76;
 					break;
 				} else {
@@ -3723,7 +3732,7 @@ partial class ExpressionFinder {
 					currentState = 165;
 					break;
 				} else {
-					if (set[134].Get(la.kind)) {
+					if (set[136].Get(la.kind)) {
 						currentState = 161;
 						break;
 					} else {
@@ -3820,39 +3829,39 @@ partial class ExpressionFinder {
 			}
 			case 174: {
 				if (la == null) { currentState = 174; break; }
-				if (set[135].Get(la.kind)) {
+				if (set[137].Get(la.kind)) {
 					currentState = 175;
 					break;
 				} else {
 					if (la.kind == 37) {
-						currentState = 481;
+						currentState = 483;
 						break;
 					} else {
-						if (set[136].Get(la.kind)) {
+						if (set[138].Get(la.kind)) {
 							currentState = 175;
 							break;
 						} else {
-							if (set[132].Get(la.kind)) {
+							if (set[134].Get(la.kind)) {
 								currentState = 175;
 								break;
 							} else {
-								if (set[134].Get(la.kind)) {
-									currentState = 477;
+								if (set[136].Get(la.kind)) {
+									currentState = 479;
 									break;
 								} else {
 									if (la.kind == 129) {
-										currentState = 474;
+										currentState = 476;
 										break;
 									} else {
 										if (la.kind == 237) {
-											currentState = 471;
+											currentState = 473;
 											break;
 										} else {
-											if (set[82].Get(la.kind)) {
+											if (set[83].Get(la.kind)) {
 												stateStack.Push(175);
 												nextTokenIsPotentialStartOfExpression = true;
 												PushContext(Context.Xml, la, t);
-												goto case 454;
+												goto case 456;
 											} else {
 												if (la.kind == 127 || la.kind == 210) {
 													stateStack.Push(175);
@@ -3932,7 +3941,7 @@ partial class ExpressionFinder {
 			}
 			case 183: {
 				if (la == null) { currentState = 183; break; }
-				if (set[137].Get(la.kind)) {
+				if (set[139].Get(la.kind)) {
 					currentState = 189;
 					break;
 				} else {
@@ -4124,7 +4133,7 @@ partial class ExpressionFinder {
 			}
 			case 205: {
 				if (la == null) { currentState = 205; break; }
-				if (set[122].Get(la.kind)) {
+				if (set[123].Get(la.kind)) {
 					currentState = stateStack.Pop();
 					break;
 				} else {
@@ -4481,7 +4490,7 @@ partial class ExpressionFinder {
 			case 252: {
 				if (la == null) { currentState = 252; break; }
 				if (la.kind == 210) {
-					currentState = 449;
+					currentState = 451;
 					break;
 				} else {
 					if (la.kind == 127) {
@@ -4547,7 +4556,7 @@ partial class ExpressionFinder {
 			}
 			case 262: {
 				if (la == null) { currentState = 262; break; }
-				if (set[138].Get(la.kind)) {
+				if (set[140].Get(la.kind)) {
 					if (set[69].Get(la.kind)) {
 						if (set[50].Get(la.kind)) {
 							stateStack.Push(260);
@@ -4664,7 +4673,7 @@ partial class ExpressionFinder {
 																currentState = 296;
 																break;
 															} else {
-																if (set[139].Get(la.kind)) {
+																if (set[141].Get(la.kind)) {
 																	if (la.kind == 132) {
 																		currentState = 293;
 																		break;
@@ -4703,7 +4712,7 @@ partial class ExpressionFinder {
 																				currentState = 269;
 																				break;
 																			} else {
-																				if (set[140].Get(la.kind)) {
+																				if (set[142].Get(la.kind)) {
 																					if (la.kind == 73) {
 																						currentState = 55;
 																						break;
@@ -5418,7 +5427,7 @@ partial class ExpressionFinder {
 			}
 			case 364: {
 				if (la == null) { currentState = 364; break; }
-				if (set[141].Get(la.kind)) {
+				if (set[143].Get(la.kind)) {
 					if (la.kind == 144) {
 						currentState = 366;
 						break;
@@ -5933,7 +5942,7 @@ partial class ExpressionFinder {
 				if (la == null) { currentState = 431; break; }
 				if (la.kind == 40) {
 					stateStack.Push(430);
-					goto case 441;
+					goto case 443;
 				} else {
 					goto case 432;
 				}
@@ -5944,7 +5953,7 @@ partial class ExpressionFinder {
 			}
 			case 433: {
 				if (la == null) { currentState = 433; break; }
-				if (set[142].Get(la.kind)) {
+				if (set[144].Get(la.kind)) {
 					currentState = 432;
 					break;
 				} else {
@@ -5960,8 +5969,8 @@ partial class ExpressionFinder {
 			}
 			case 435: {
 				if (la == null) { currentState = 435; break; }
-				if (la.kind == 63) {
-					currentState = 439;
+				if (la.kind == 33) {
+					currentState = 436;
 					break;
 				} else {
 					goto case 436;
@@ -5969,67 +5978,92 @@ partial class ExpressionFinder {
 			}
 			case 436: {
 				if (la == null) { currentState = 436; break; }
-				if (la.kind == 20) {
-					currentState = 438;
+				if (la.kind == 37) {
+					currentState = 442;
 					break;
 				} else {
-					goto case 437;
+					if (la.kind == 63) {
+						currentState = 440;
+						break;
+					} else {
+						goto case 437;
+					}
 				}
 			}
 			case 437: {
+				if (la == null) { currentState = 437; break; }
+				if (la.kind == 20) {
+					currentState = 439;
+					break;
+				} else {
+					goto case 438;
+				}
+			}
+			case 438: {
 				PopContext();
 				currentState = stateStack.Pop();
 				goto switchlbl;
 			}
-			case 438: {
-				stateStack.Push(437);
+			case 439: {
+				stateStack.Push(438);
 				goto case 55;
 			}
-			case 439: {
+			case 440: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(440);
+				stateStack.Push(441);
 				goto case 37;
 			}
-			case 440: {
+			case 441: {
 				PopContext();
-				goto case 436;
+				goto case 437;
 			}
-			case 441: {
-				if (la == null) { currentState = 441; break; }
+			case 442: {
+				if (la == null) { currentState = 442; break; }
+				if (la.kind == 22) {
+					currentState = 442;
+					break;
+				} else {
+					Expect(38, la); // ")"
+					currentState = 436;
+					break;
+				}
+			}
+			case 443: {
+				if (la == null) { currentState = 443; break; }
 				Expect(40, la); // "<"
-				currentState = 442;
+				currentState = 444;
 				break;
 			}
-			case 442: {
+			case 444: {
 				wasNormalAttribute = true; PushContext(Context.Attribute, la, t);
-				goto case 443;
+				goto case 445;
 			}
-			case 443: {
-				if (la == null) { currentState = 443; break; }
+			case 445: {
+				if (la == null) { currentState = 445; break; }
 				if (la.kind == 65 || la.kind == 155) {
-					currentState = 447;
+					currentState = 449;
 					break;
 				} else {
-					goto case 444;
+					goto case 446;
 				}
 			}
-			case 444: {
-				if (la == null) { currentState = 444; break; }
-				if (set[143].Get(la.kind)) {
-					currentState = 444;
+			case 446: {
+				if (la == null) { currentState = 446; break; }
+				if (set[145].Get(la.kind)) {
+					currentState = 446;
 					break;
 				} else {
 					Expect(39, la); // ">"
-					currentState = 445;
+					currentState = 447;
 					break;
 				}
 			}
-			case 445: {
+			case 447: {
 				PopContext();
-				goto case 446;
+				goto case 448;
 			}
-			case 446: {
-				if (la == null) { currentState = 446; break; }
+			case 448: {
+				if (la == null) { currentState = 448; break; }
 				if (la.kind == 1) {
 					goto case 25;
 				} else {
@@ -6037,287 +6071,287 @@ partial class ExpressionFinder {
 					goto switchlbl;
 				}
 			}
-			case 447: {
-				if (la == null) { currentState = 447; break; }
+			case 449: {
+				if (la == null) { currentState = 449; break; }
 				Expect(21, la); // ":"
-				currentState = 448;
+				currentState = 450;
 				break;
 			}
-			case 448: {
+			case 450: {
 				wasNormalAttribute = false;
-				goto case 444;
+				goto case 446;
 			}
-			case 449: {
-				stateStack.Push(450);
+			case 451: {
+				stateStack.Push(452);
 				goto case 424;
 			}
-			case 450: {
+			case 452: {
 				nextTokenIsPotentialStartOfExpression = true;
-				goto case 451;
+				goto case 453;
 			}
-			case 451: {
-				if (la == null) { currentState = 451; break; }
+			case 453: {
+				if (la == null) { currentState = 453; break; }
 				if (set[50].Get(la.kind)) {
 					goto case 267;
 				} else {
 					if (la.kind == 1 || la.kind == 21) {
-						stateStack.Push(452);
+						stateStack.Push(454);
 						goto case 259;
 					} else {
 						goto case 6;
 					}
 				}
 			}
-			case 452: {
-				if (la == null) { currentState = 452; break; }
+			case 454: {
+				if (la == null) { currentState = 454; break; }
 				Expect(113, la); // "End"
-				currentState = 453;
+				currentState = 455;
 				break;
 			}
-			case 453: {
-				if (la == null) { currentState = 453; break; }
+			case 455: {
+				if (la == null) { currentState = 455; break; }
 				Expect(210, la); // "Sub"
 				currentState = stateStack.Pop();
 				break;
 			}
-			case 454: {
-				if (la == null) { currentState = 454; break; }
+			case 456: {
+				if (la == null) { currentState = 456; break; }
 				if (la.kind == 17 || la.kind == 18 || la.kind == 19) {
-					currentState = 467;
+					currentState = 469;
 					break;
 				} else {
 					if (la.kind == 10) {
-						stateStack.Push(456);
-						goto case 458;
+						stateStack.Push(458);
+						goto case 460;
 					} else {
 						Error(la);
-						goto case 455;
+						goto case 457;
 					}
 				}
 			}
-			case 455: {
+			case 457: {
 				PopContext();
 				currentState = stateStack.Pop();
 				goto switchlbl;
 			}
-			case 456: {
-				if (la == null) { currentState = 456; break; }
+			case 458: {
+				if (la == null) { currentState = 458; break; }
 				if (la.kind == 17) {
-					currentState = 457;
+					currentState = 459;
 					break;
 				} else {
-					goto case 455;
+					goto case 457;
 				}
 			}
-			case 457: {
-				if (la == null) { currentState = 457; break; }
+			case 459: {
+				if (la == null) { currentState = 459; break; }
 				if (la.kind == 16) {
-					currentState = 456;
+					currentState = 458;
 					break;
 				} else {
-					goto case 456;
+					goto case 458;
 				}
 			}
-			case 458: {
+			case 460: {
 				PushContext(Context.Xml, la, t);
-				goto case 459;
+				goto case 461;
 			}
-			case 459: {
-				if (la == null) { currentState = 459; break; }
+			case 461: {
+				if (la == null) { currentState = 461; break; }
 				Expect(10, la); // XmlOpenTag
-				currentState = 460;
+				currentState = 462;
 				break;
 			}
-			case 460: {
-				if (la == null) { currentState = 460; break; }
-				if (set[144].Get(la.kind)) {
-					if (set[145].Get(la.kind)) {
-						currentState = 460;
+			case 462: {
+				if (la == null) { currentState = 462; break; }
+				if (set[146].Get(la.kind)) {
+					if (set[147].Get(la.kind)) {
+						currentState = 462;
 						break;
 					} else {
 						if (la.kind == 12) {
-							stateStack.Push(460);
-							goto case 464;
+							stateStack.Push(462);
+							goto case 466;
 						} else {
 							Error(la);
-							goto case 460;
+							goto case 462;
 						}
 					}
 				} else {
 					if (la.kind == 14) {
-						currentState = 461;
+						currentState = 463;
 						break;
 					} else {
 						if (la.kind == 11) {
-							currentState = 462;
+							currentState = 464;
 							break;
 						} else {
 							Error(la);
-							goto case 461;
+							goto case 463;
 						}
 					}
 				}
 			}
-			case 461: {
+			case 463: {
 				PopContext();
 				currentState = stateStack.Pop();
 				goto switchlbl;
 			}
-			case 462: {
-				if (la == null) { currentState = 462; break; }
-				if (set[146].Get(la.kind)) {
-					if (set[147].Get(la.kind)) {
-						currentState = 462;
+			case 464: {
+				if (la == null) { currentState = 464; break; }
+				if (set[148].Get(la.kind)) {
+					if (set[149].Get(la.kind)) {
+						currentState = 464;
 						break;
 					} else {
 						if (la.kind == 12) {
-							stateStack.Push(462);
-							goto case 464;
+							stateStack.Push(464);
+							goto case 466;
 						} else {
 							if (la.kind == 10) {
-								stateStack.Push(462);
-								goto case 458;
+								stateStack.Push(464);
+								goto case 460;
 							} else {
 								Error(la);
-								goto case 462;
+								goto case 464;
 							}
 						}
 					}
 				} else {
 					Expect(15, la); // XmlOpenEndTag
-					currentState = 463;
+					currentState = 465;
 					break;
 				}
 			}
-			case 463: {
-				if (la == null) { currentState = 463; break; }
-				if (set[148].Get(la.kind)) {
-					if (set[149].Get(la.kind)) {
-						currentState = 463;
+			case 465: {
+				if (la == null) { currentState = 465; break; }
+				if (set[150].Get(la.kind)) {
+					if (set[151].Get(la.kind)) {
+						currentState = 465;
 						break;
 					} else {
 						if (la.kind == 12) {
-							stateStack.Push(463);
-							goto case 464;
+							stateStack.Push(465);
+							goto case 466;
 						} else {
 							Error(la);
-							goto case 463;
+							goto case 465;
 						}
 					}
 				} else {
 					Expect(11, la); // XmlCloseTag
-					currentState = 461;
+					currentState = 463;
 					break;
 				}
 			}
-			case 464: {
-				if (la == null) { currentState = 464; break; }
+			case 466: {
+				if (la == null) { currentState = 466; break; }
 				Expect(12, la); // XmlStartInlineVB
-				currentState = 465;
+				currentState = 467;
 				break;
 			}
-			case 465: {
-				stateStack.Push(466);
+			case 467: {
+				stateStack.Push(468);
 				goto case 55;
 			}
-			case 466: {
-				if (la == null) { currentState = 466; break; }
+			case 468: {
+				if (la == null) { currentState = 468; break; }
 				Expect(13, la); // XmlEndInlineVB
 				currentState = stateStack.Pop();
 				break;
 			}
-			case 467: {
-				if (la == null) { currentState = 467; break; }
+			case 469: {
+				if (la == null) { currentState = 469; break; }
 				if (la.kind == 16) {
-					currentState = 468;
+					currentState = 470;
 					break;
 				} else {
-					goto case 468;
+					goto case 470;
 				}
 			}
-			case 468: {
-				if (la == null) { currentState = 468; break; }
+			case 470: {
+				if (la == null) { currentState = 470; break; }
 				if (la.kind == 17 || la.kind == 19) {
-					currentState = 467;
+					currentState = 469;
 					break;
 				} else {
 					if (la.kind == 10) {
-						stateStack.Push(469);
-						goto case 458;
+						stateStack.Push(471);
+						goto case 460;
 					} else {
-						goto case 455;
+						goto case 457;
 					}
 				}
 			}
-			case 469: {
-				if (la == null) { currentState = 469; break; }
+			case 471: {
+				if (la == null) { currentState = 471; break; }
 				if (la.kind == 17) {
-					currentState = 470;
+					currentState = 472;
 					break;
 				} else {
-					goto case 455;
+					goto case 457;
 				}
 			}
-			case 470: {
-				if (la == null) { currentState = 470; break; }
+			case 472: {
+				if (la == null) { currentState = 472; break; }
 				if (la.kind == 16) {
-					currentState = 469;
+					currentState = 471;
 					break;
 				} else {
-					goto case 469;
+					goto case 471;
 				}
 			}
-			case 471: {
-				if (la == null) { currentState = 471; break; }
+			case 473: {
+				if (la == null) { currentState = 473; break; }
 				Expect(37, la); // "("
-				currentState = 472;
+				currentState = 474;
 				break;
 			}
-			case 472: {
+			case 474: {
 				readXmlIdentifier = true;
-				stateStack.Push(473);
+				stateStack.Push(475);
 				goto case 205;
 			}
-			case 473: {
-				if (la == null) { currentState = 473; break; }
+			case 475: {
+				if (la == null) { currentState = 475; break; }
 				Expect(38, la); // ")"
 				currentState = 175;
 				break;
 			}
-			case 474: {
-				if (la == null) { currentState = 474; break; }
+			case 476: {
+				if (la == null) { currentState = 476; break; }
 				Expect(37, la); // "("
-				currentState = 475;
+				currentState = 477;
 				break;
 			}
-			case 475: {
+			case 477: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(476);
+				stateStack.Push(478);
 				goto case 37;
 			}
-			case 476: {
+			case 478: {
 				PopContext();
-				goto case 473;
+				goto case 475;
 			}
-			case 477: {
+			case 479: {
 				nextTokenIsStartOfImportsOrAccessExpression = true; wasQualifierTokenAtStart = true;
-				goto case 478;
+				goto case 480;
 			}
-			case 478: {
-				if (la == null) { currentState = 478; break; }
+			case 480: {
+				if (la == null) { currentState = 480; break; }
 				if (la.kind == 10) {
-					currentState = 479;
+					currentState = 481;
 					break;
 				} else {
-					goto case 479;
+					goto case 481;
 				}
 			}
-			case 479: {
-				stateStack.Push(480);
+			case 481: {
+				stateStack.Push(482);
 				goto case 101;
 			}
-			case 480: {
-				if (la == null) { currentState = 480; break; }
+			case 482: {
+				if (la == null) { currentState = 482; break; }
 				if (la.kind == 11) {
 					currentState = 175;
 					break;
@@ -6325,235 +6359,235 @@ partial class ExpressionFinder {
 					goto case 175;
 				}
 			}
-			case 481: {
+			case 483: {
 				activeArgument = 0;
-				goto case 482;
+				goto case 484;
 			}
-			case 482: {
-				stateStack.Push(483);
+			case 484: {
+				stateStack.Push(485);
 				goto case 55;
 			}
-			case 483: {
-				if (la == null) { currentState = 483; break; }
+			case 485: {
+				if (la == null) { currentState = 485; break; }
 				if (la.kind == 22) {
-					currentState = 484;
+					currentState = 486;
 					break;
 				} else {
-					goto case 473;
+					goto case 475;
 				}
 			}
-			case 484: {
+			case 486: {
 				activeArgument++;
-				goto case 482;
+				goto case 484;
 			}
-			case 485: {
-				stateStack.Push(486);
+			case 487: {
+				stateStack.Push(488);
 				goto case 55;
 			}
-			case 486: {
-				if (la == null) { currentState = 486; break; }
+			case 488: {
+				if (la == null) { currentState = 488; break; }
 				if (la.kind == 22) {
-					currentState = 487;
+					currentState = 489;
 					break;
 				} else {
 					currentState = stateStack.Pop();
 					goto switchlbl;
 				}
 			}
-			case 487: {
+			case 489: {
 				activeArgument++;
 				nextTokenIsPotentialStartOfExpression = true;
-				goto case 488;
+				goto case 490;
 			}
-			case 488: {
-				if (la == null) { currentState = 488; break; }
+			case 490: {
+				if (la == null) { currentState = 490; break; }
 				if (set[23].Get(la.kind)) {
-					goto case 485;
+					goto case 487;
 				} else {
-					goto case 486;
+					goto case 488;
 				}
 			}
-			case 489: {
-				if (la == null) { currentState = 489; break; }
+			case 491: {
+				if (la == null) { currentState = 491; break; }
 				if (set[16].Get(la.kind)) {
 					PushContext(Context.Type, la, t);
-					stateStack.Push(493);
+					stateStack.Push(495);
 					goto case 37;
 				} else {
-					goto case 490;
+					goto case 492;
 				}
 			}
-			case 490: {
-				if (la == null) { currentState = 490; break; }
+			case 492: {
+				if (la == null) { currentState = 492; break; }
 				if (la.kind == 22) {
-					currentState = 491;
+					currentState = 493;
 					break;
 				} else {
 					goto case 45;
 				}
 			}
-			case 491: {
-				if (la == null) { currentState = 491; break; }
+			case 493: {
+				if (la == null) { currentState = 493; break; }
 				if (set[16].Get(la.kind)) {
 					PushContext(Context.Type, la, t);
-					stateStack.Push(492);
+					stateStack.Push(494);
 					goto case 37;
 				} else {
-					goto case 490;
+					goto case 492;
 				}
 			}
-			case 492: {
+			case 494: {
 				PopContext();
-				goto case 490;
+				goto case 492;
 			}
-			case 493: {
+			case 495: {
 				PopContext();
-				goto case 490;
+				goto case 492;
 			}
-			case 494: {
+			case 496: {
 				SetIdentifierExpected(la);
-				goto case 495;
+				goto case 497;
 			}
-			case 495: {
-				if (la == null) { currentState = 495; break; }
-				if (set[150].Get(la.kind)) {
+			case 497: {
+				if (la == null) { currentState = 497; break; }
+				if (set[152].Get(la.kind)) {
 					if (la.kind == 169) {
-						currentState = 497;
+						currentState = 499;
 						break;
 					} else {
 						if (set[77].Get(la.kind)) {
-							stateStack.Push(496);
+							stateStack.Push(498);
 							goto case 428;
 						} else {
 							Error(la);
-							goto case 496;
+							goto case 498;
 						}
 					}
 				} else {
-					goto case 496;
+					goto case 498;
 				}
 			}
-			case 496: {
-				if (la == null) { currentState = 496; break; }
+			case 498: {
+				if (la == null) { currentState = 498; break; }
 				Expect(38, la); // ")"
 				currentState = 34;
 				break;
 			}
-			case 497: {
-				stateStack.Push(496);
-				goto case 498;
+			case 499: {
+				stateStack.Push(498);
+				goto case 500;
 			}
-			case 498: {
+			case 500: {
 				SetIdentifierExpected(la);
-				goto case 499;
+				goto case 501;
 			}
-			case 499: {
-				if (la == null) { currentState = 499; break; }
+			case 501: {
+				if (la == null) { currentState = 501; break; }
 				if (la.kind == 138 || la.kind == 178) {
-					currentState = 500;
+					currentState = 502;
 					break;
 				} else {
-					goto case 500;
+					goto case 502;
 				}
 			}
-			case 500: {
+			case 502: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(501);
-				goto case 515;
+				stateStack.Push(503);
+				goto case 517;
 			}
-			case 501: {
+			case 503: {
 				PopContext();
-				goto case 502;
+				goto case 504;
 			}
-			case 502: {
-				if (la == null) { currentState = 502; break; }
+			case 504: {
+				if (la == null) { currentState = 504; break; }
 				if (la.kind == 63) {
-					currentState = 516;
+					currentState = 518;
 					break;
 				} else {
-					goto case 503;
+					goto case 505;
 				}
 			}
-			case 503: {
-				if (la == null) { currentState = 503; break; }
+			case 505: {
+				if (la == null) { currentState = 505; break; }
 				if (la.kind == 22) {
-					currentState = 504;
+					currentState = 506;
 					break;
 				} else {
 					currentState = stateStack.Pop();
 					goto switchlbl;
 				}
 			}
-			case 504: {
+			case 506: {
 				SetIdentifierExpected(la);
-				goto case 505;
+				goto case 507;
 			}
-			case 505: {
-				if (la == null) { currentState = 505; break; }
+			case 507: {
+				if (la == null) { currentState = 507; break; }
 				if (la.kind == 138 || la.kind == 178) {
-					currentState = 506;
+					currentState = 508;
 					break;
 				} else {
-					goto case 506;
+					goto case 508;
 				}
 			}
-			case 506: {
+			case 508: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(507);
-				goto case 515;
+				stateStack.Push(509);
+				goto case 517;
 			}
-			case 507: {
+			case 509: {
 				PopContext();
-				goto case 508;
+				goto case 510;
 			}
-			case 508: {
-				if (la == null) { currentState = 508; break; }
+			case 510: {
+				if (la == null) { currentState = 510; break; }
 				if (la.kind == 63) {
-					currentState = 509;
+					currentState = 511;
 					break;
 				} else {
-					goto case 503;
+					goto case 505;
 				}
 			}
-			case 509: {
+			case 511: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(510);
-				goto case 511;
+				stateStack.Push(512);
+				goto case 513;
 			}
-			case 510: {
+			case 512: {
 				PopContext();
-				goto case 503;
+				goto case 505;
 			}
-			case 511: {
-				if (la == null) { currentState = 511; break; }
-				if (set[93].Get(la.kind)) {
-					goto case 514;
+			case 513: {
+				if (la == null) { currentState = 513; break; }
+				if (set[94].Get(la.kind)) {
+					goto case 516;
 				} else {
 					if (la.kind == 35) {
-						currentState = 512;
+						currentState = 514;
 						break;
 					} else {
 						goto case 6;
 					}
 				}
 			}
-			case 512: {
-				stateStack.Push(513);
-				goto case 514;
+			case 514: {
+				stateStack.Push(515);
+				goto case 516;
 			}
-			case 513: {
-				if (la == null) { currentState = 513; break; }
+			case 515: {
+				if (la == null) { currentState = 515; break; }
 				if (la.kind == 22) {
-					currentState = 512;
+					currentState = 514;
 					break;
 				} else {
 					goto case 82;
 				}
 			}
-			case 514: {
-				if (la == null) { currentState = 514; break; }
+			case 516: {
+				if (la == null) { currentState = 516; break; }
 				if (set[16].Get(la.kind)) {
 					currentState = 38;
 					break;
@@ -6573,8 +6607,8 @@ partial class ExpressionFinder {
 					}
 				}
 			}
-			case 515: {
-				if (la == null) { currentState = 515; break; }
+			case 517: {
+				if (la == null) { currentState = 517; break; }
 				if (la.kind == 2) {
 					goto case 145;
 				} else {
@@ -6681,357 +6715,343 @@ partial class ExpressionFinder {
 					}
 				}
 			}
-			case 516: {
+			case 518: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(517);
-				goto case 511;
+				stateStack.Push(519);
+				goto case 513;
 			}
-			case 517: {
+			case 519: {
 				PopContext();
-				goto case 503;
+				goto case 505;
 			}
-			case 518: {
+			case 520: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(519);
+				stateStack.Push(521);
 				goto case 205;
 			}
-			case 519: {
+			case 521: {
 				PopContext();
-				goto case 520;
+				goto case 522;
 			}
-			case 520: {
-				if (la == null) { currentState = 520; break; }
+			case 522: {
+				if (la == null) { currentState = 522; break; }
 				if (la.kind == 37) {
-					stateStack.Push(521);
+					stateStack.Push(523);
 					goto case 424;
 				} else {
-					goto case 521;
+					goto case 523;
 				}
 			}
-			case 521: {
-				if (la == null) { currentState = 521; break; }
+			case 523: {
+				if (la == null) { currentState = 523; break; }
 				if (la.kind == 63) {
-					currentState = 522;
+					currentState = 524;
 					break;
 				} else {
 					goto case 23;
 				}
 			}
-			case 522: {
+			case 524: {
 				PushContext(Context.Type, la, t);
-				goto case 523;
+				goto case 525;
 			}
-			case 523: {
-				if (la == null) { currentState = 523; break; }
+			case 525: {
+				if (la == null) { currentState = 525; break; }
 				if (la.kind == 40) {
-					stateStack.Push(523);
-					goto case 441;
+					stateStack.Push(525);
+					goto case 443;
 				} else {
-					stateStack.Push(524);
+					stateStack.Push(526);
 					goto case 37;
 				}
 			}
-			case 524: {
+			case 526: {
 				PopContext();
 				goto case 23;
 			}
-			case 525: {
+			case 527: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(526);
+				stateStack.Push(528);
 				goto case 205;
 			}
-			case 526: {
+			case 528: {
 				PopContext();
-				goto case 527;
+				goto case 529;
 			}
-			case 527: {
-				if (la == null) { currentState = 527; break; }
+			case 529: {
+				if (la == null) { currentState = 529; break; }
 				if (la.kind == 37 || la.kind == 63) {
 					if (la.kind == 63) {
-						currentState = 529;
+						currentState = 531;
 						break;
 					} else {
 						if (la.kind == 37) {
 							stateStack.Push(23);
 							goto case 424;
 						} else {
-							goto case 528;
+							goto case 530;
 						}
 					}
 				} else {
 					goto case 23;
 				}
 			}
-			case 528: {
+			case 530: {
 				Error(la);
 				goto case 23;
 			}
-			case 529: {
+			case 531: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(530);
+				stateStack.Push(532);
 				goto case 37;
 			}
-			case 530: {
+			case 532: {
 				PopContext();
 				goto case 23;
 			}
-			case 531: {
+			case 533: {
 				PushContext(Context.TypeDeclaration, la, t);
-				goto case 532;
+				goto case 534;
 			}
-			case 532: {
-				if (la == null) { currentState = 532; break; }
+			case 534: {
+				if (la == null) { currentState = 534; break; }
 				Expect(115, la); // "Enum"
-				currentState = 533;
+				currentState = 535;
 				break;
 			}
-			case 533: {
+			case 535: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(534);
+				stateStack.Push(536);
 				goto case 205;
 			}
-			case 534: {
+			case 536: {
 				PopContext();
-				goto case 535;
+				goto case 537;
 			}
-			case 535: {
-				if (la == null) { currentState = 535; break; }
+			case 537: {
+				if (la == null) { currentState = 537; break; }
 				if (la.kind == 63) {
-					currentState = 547;
+					currentState = 549;
 					break;
 				} else {
-					goto case 536;
+					goto case 538;
 				}
 			}
-			case 536: {
-				stateStack.Push(537);
+			case 538: {
+				stateStack.Push(539);
 				goto case 23;
 			}
-			case 537: {
+			case 539: {
 				SetIdentifierExpected(la);
-				goto case 538;
+				goto case 540;
 			}
-			case 538: {
-				if (la == null) { currentState = 538; break; }
-				if (set[96].Get(la.kind)) {
-					goto case 542;
+			case 540: {
+				if (la == null) { currentState = 540; break; }
+				if (set[97].Get(la.kind)) {
+					goto case 544;
 				} else {
 					Expect(113, la); // "End"
-					currentState = 539;
+					currentState = 541;
 					break;
 				}
 			}
-			case 539: {
-				if (la == null) { currentState = 539; break; }
+			case 541: {
+				if (la == null) { currentState = 541; break; }
 				Expect(115, la); // "Enum"
-				currentState = 540;
+				currentState = 542;
 				break;
 			}
-			case 540: {
-				stateStack.Push(541);
+			case 542: {
+				stateStack.Push(543);
 				goto case 23;
 			}
-			case 541: {
+			case 543: {
 				PopContext();
 				currentState = stateStack.Pop();
 				goto switchlbl;
 			}
-			case 542: {
+			case 544: {
 				SetIdentifierExpected(la);
-				goto case 543;
+				goto case 545;
 			}
-			case 543: {
-				if (la == null) { currentState = 543; break; }
+			case 545: {
+				if (la == null) { currentState = 545; break; }
 				if (la.kind == 40) {
-					stateStack.Push(542);
-					goto case 441;
+					stateStack.Push(544);
+					goto case 443;
 				} else {
 					PushContext(Context.Identifier, la, t);
 					SetIdentifierExpected(la);
-					stateStack.Push(544);
+					stateStack.Push(546);
 					goto case 205;
 				}
 			}
-			case 544: {
+			case 546: {
 				PopContext();
-				goto case 545;
+				goto case 547;
 			}
-			case 545: {
-				if (la == null) { currentState = 545; break; }
+			case 547: {
+				if (la == null) { currentState = 547; break; }
 				if (la.kind == 20) {
-					currentState = 546;
+					currentState = 548;
 					break;
 				} else {
-					goto case 536;
+					goto case 538;
 				}
 			}
-			case 546: {
-				stateStack.Push(536);
+			case 548: {
+				stateStack.Push(538);
 				goto case 55;
 			}
-			case 547: {
+			case 549: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(548);
+				stateStack.Push(550);
 				goto case 37;
 			}
-			case 548: {
+			case 550: {
 				PopContext();
-				goto case 536;
+				goto case 538;
 			}
-			case 549: {
-				if (la == null) { currentState = 549; break; }
+			case 551: {
+				if (la == null) { currentState = 551; break; }
 				Expect(103, la); // "Delegate"
-				currentState = 550;
+				currentState = 552;
 				break;
 			}
-			case 550: {
-				if (la == null) { currentState = 550; break; }
+			case 552: {
+				if (la == null) { currentState = 552; break; }
 				if (la.kind == 210) {
-					currentState = 551;
+					currentState = 553;
 					break;
 				} else {
 					if (la.kind == 127) {
-						currentState = 551;
+						currentState = 553;
 						break;
 					} else {
 						Error(la);
-						goto case 551;
+						goto case 553;
 					}
 				}
 			}
-			case 551: {
+			case 553: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				goto case 552;
+				goto case 554;
 			}
-			case 552: {
-				if (la == null) { currentState = 552; break; }
-				currentState = 553;
+			case 554: {
+				if (la == null) { currentState = 554; break; }
+				currentState = 555;
 				break;
 			}
-			case 553: {
+			case 555: {
 				PopContext();
-				goto case 554;
+				goto case 556;
 			}
-			case 554: {
-				if (la == null) { currentState = 554; break; }
+			case 556: {
+				if (la == null) { currentState = 556; break; }
 				if (la.kind == 37) {
-					currentState = 557;
+					currentState = 559;
 					break;
 				} else {
 					if (la.kind == 63) {
-						currentState = 555;
+						currentState = 557;
 						break;
 					} else {
 						goto case 23;
 					}
 				}
 			}
-			case 555: {
+			case 557: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(556);
+				stateStack.Push(558);
 				goto case 37;
 			}
-			case 556: {
+			case 558: {
 				PopContext();
 				goto case 23;
 			}
-			case 557: {
+			case 559: {
 				SetIdentifierExpected(la);
-				goto case 558;
+				goto case 560;
 			}
-			case 558: {
-				if (la == null) { currentState = 558; break; }
-				if (set[150].Get(la.kind)) {
+			case 560: {
+				if (la == null) { currentState = 560; break; }
+				if (set[152].Get(la.kind)) {
 					if (la.kind == 169) {
-						currentState = 560;
+						currentState = 562;
 						break;
 					} else {
 						if (set[77].Get(la.kind)) {
-							stateStack.Push(559);
+							stateStack.Push(561);
 							goto case 428;
 						} else {
 							Error(la);
-							goto case 559;
+							goto case 561;
 						}
 					}
 				} else {
-					goto case 559;
+					goto case 561;
 				}
 			}
-			case 559: {
-				if (la == null) { currentState = 559; break; }
+			case 561: {
+				if (la == null) { currentState = 561; break; }
 				Expect(38, la); // ")"
-				currentState = 554;
+				currentState = 556;
 				break;
 			}
-			case 560: {
-				stateStack.Push(559);
-				goto case 498;
+			case 562: {
+				stateStack.Push(561);
+				goto case 500;
 			}
-			case 561: {
+			case 563: {
 				PushContext(Context.TypeDeclaration, la, t);
-				goto case 562;
+				goto case 564;
 			}
-			case 562: {
-				if (la == null) { currentState = 562; break; }
+			case 564: {
+				if (la == null) { currentState = 564; break; }
 				if (la.kind == 155) {
-					currentState = 563;
+					currentState = 565;
 					break;
 				} else {
 					if (la.kind == 84) {
-						currentState = 563;
+						currentState = 565;
 						break;
 					} else {
 						if (la.kind == 209) {
-							currentState = 563;
+							currentState = 565;
 							break;
 						} else {
 							Error(la);
-							goto case 563;
+							goto case 565;
 						}
 					}
 				}
 			}
-			case 563: {
+			case 565: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(564);
+				stateStack.Push(566);
 				goto case 205;
 			}
-			case 564: {
+			case 566: {
 				PopContext();
-				goto case 565;
+				goto case 567;
 			}
-			case 565: {
-				if (la == null) { currentState = 565; break; }
+			case 567: {
+				if (la == null) { currentState = 567; break; }
 				if (la.kind == 37) {
-					currentState = 715;
+					currentState = 717;
 					break;
 				} else {
-					goto case 566;
+					goto case 568;
 				}
 			}
-			case 566: {
-				stateStack.Push(567);
-				goto case 23;
-			}
-			case 567: {
-				SetIdentifierExpected(la);
-				isMissingModifier = true;
-				goto case 568;
-			}
 			case 568: {
-				if (la == null) { currentState = 568; break; }
-				if (la.kind == 140) {
-					isMissingModifier = false;
-					goto case 712;
-				} else {
-					goto case 569;
-				}
+				stateStack.Push(569);
+				goto case 23;
 			}
 			case 569: {
 				SetIdentifierExpected(la);
@@ -7040,9 +7060,9 @@ partial class ExpressionFinder {
 			}
 			case 570: {
 				if (la == null) { currentState = 570; break; }
-				if (la.kind == 136) {
+				if (la.kind == 140) {
 					isMissingModifier = false;
-					goto case 706;
+					goto case 714;
 				} else {
 					goto case 571;
 				}
@@ -7054,142 +7074,156 @@ partial class ExpressionFinder {
 			}
 			case 572: {
 				if (la == null) { currentState = 572; break; }
-				if (set[100].Get(la.kind)) {
-					goto case 577;
-				} else {
+				if (la.kind == 136) {
 					isMissingModifier = false;
+					goto case 708;
+				} else {
 					goto case 573;
 				}
 			}
 			case 573: {
-				if (la == null) { currentState = 573; break; }
-				Expect(113, la); // "End"
-				currentState = 574;
-				break;
+				SetIdentifierExpected(la);
+				isMissingModifier = true;
+				goto case 574;
 			}
 			case 574: {
 				if (la == null) { currentState = 574; break; }
+				if (set[101].Get(la.kind)) {
+					goto case 579;
+				} else {
+					isMissingModifier = false;
+					goto case 575;
+				}
+			}
+			case 575: {
+				if (la == null) { currentState = 575; break; }
+				Expect(113, la); // "End"
+				currentState = 576;
+				break;
+			}
+			case 576: {
+				if (la == null) { currentState = 576; break; }
 				if (la.kind == 155) {
-					currentState = 575;
+					currentState = 577;
 					break;
 				} else {
 					if (la.kind == 84) {
-						currentState = 575;
+						currentState = 577;
 						break;
 					} else {
 						if (la.kind == 209) {
-							currentState = 575;
+							currentState = 577;
 							break;
 						} else {
 							Error(la);
-							goto case 575;
+							goto case 577;
 						}
 					}
 				}
 			}
-			case 575: {
-				stateStack.Push(576);
+			case 577: {
+				stateStack.Push(578);
 				goto case 23;
 			}
-			case 576: {
+			case 578: {
 				PopContext();
 				currentState = stateStack.Pop();
 				goto switchlbl;
 			}
-			case 577: {
+			case 579: {
 				SetIdentifierExpected(la);
 				isMissingModifier = true;
-				goto case 578;
+				goto case 580;
 			}
-			case 578: {
-				if (la == null) { currentState = 578; break; }
+			case 580: {
+				if (la == null) { currentState = 580; break; }
 				if (la.kind == 40) {
-					stateStack.Push(577);
-					goto case 441;
+					stateStack.Push(579);
+					goto case 443;
 				} else {
 					isMissingModifier = true;
-					goto case 579;
+					goto case 581;
 				}
 			}
-			case 579: {
+			case 581: {
 				SetIdentifierExpected(la);
-				goto case 580;
+				goto case 582;
 			}
-			case 580: {
-				if (la == null) { currentState = 580; break; }
-				if (set[131].Get(la.kind)) {
-					currentState = 705;
+			case 582: {
+				if (la == null) { currentState = 582; break; }
+				if (set[133].Get(la.kind)) {
+					currentState = 707;
 					break;
 				} else {
 					isMissingModifier = false;
 					SetIdentifierExpected(la);
-					goto case 581;
+					goto case 583;
 				}
 			}
-			case 581: {
-				if (la == null) { currentState = 581; break; }
+			case 583: {
+				if (la == null) { currentState = 583; break; }
 				if (la.kind == 84 || la.kind == 155 || la.kind == 209) {
-					stateStack.Push(571);
-					goto case 561;
+					stateStack.Push(573);
+					goto case 563;
 				} else {
 					if (la.kind == 103) {
-						stateStack.Push(571);
-						goto case 549;
+						stateStack.Push(573);
+						goto case 551;
 					} else {
 						if (la.kind == 115) {
-							stateStack.Push(571);
-							goto case 531;
+							stateStack.Push(573);
+							goto case 533;
 						} else {
 							if (la.kind == 142) {
-								stateStack.Push(571);
+								stateStack.Push(573);
 								goto case 9;
 							} else {
-								if (set[103].Get(la.kind)) {
-									stateStack.Push(571);
+								if (set[104].Get(la.kind)) {
+									stateStack.Push(573);
 									PushContext(Context.Member, la, t);
 									SetIdentifierExpected(la);
-									goto case 582;
+									goto case 584;
 								} else {
 									Error(la);
-									goto case 571;
+									goto case 573;
 								}
 							}
 						}
 					}
 				}
 			}
-			case 582: {
-				if (la == null) { currentState = 582; break; }
-				if (set[121].Get(la.kind)) {
-					stateStack.Push(583);
-					goto case 690;
+			case 584: {
+				if (la == null) { currentState = 584; break; }
+				if (set[122].Get(la.kind)) {
+					stateStack.Push(585);
+					goto case 692;
 				} else {
 					if (la.kind == 127 || la.kind == 210) {
-						stateStack.Push(583);
-						goto case 672;
+						stateStack.Push(585);
+						goto case 674;
 					} else {
 						if (la.kind == 101) {
-							stateStack.Push(583);
-							goto case 659;
+							stateStack.Push(585);
+							goto case 661;
 						} else {
 							if (la.kind == 119) {
-								stateStack.Push(583);
-								goto case 647;
+								stateStack.Push(585);
+								goto case 649;
 							} else {
 								if (la.kind == 98) {
-									stateStack.Push(583);
-									goto case 635;
+									stateStack.Push(585);
+									goto case 637;
 								} else {
 									if (la.kind == 186) {
-										stateStack.Push(583);
-										goto case 598;
+										stateStack.Push(585);
+										goto case 600;
 									} else {
 										if (la.kind == 172) {
-											stateStack.Push(583);
-											goto case 584;
+											stateStack.Push(585);
+											goto case 586;
 										} else {
 											Error(la);
-											goto case 583;
+											goto case 585;
 										}
 									}
 								}
@@ -7198,716 +7232,716 @@ partial class ExpressionFinder {
 					}
 				}
 			}
-			case 583: {
+			case 585: {
 				PopContext();
 				currentState = stateStack.Pop();
 				goto switchlbl;
 			}
-			case 584: {
-				if (la == null) { currentState = 584; break; }
-				Expect(172, la); // "Operator"
-				currentState = 585;
-				break;
-			}
-			case 585: {
-				PushContext(Context.Identifier, la, t);
-				SetIdentifierExpected(la);
-				goto case 586;
-			}
 			case 586: {
 				if (la == null) { currentState = 586; break; }
+				Expect(172, la); // "Operator"
 				currentState = 587;
 				break;
 			}
 			case 587: {
-				PopContext();
+				PushContext(Context.Identifier, la, t);
+				SetIdentifierExpected(la);
 				goto case 588;
 			}
 			case 588: {
 				if (la == null) { currentState = 588; break; }
-				Expect(37, la); // "("
 				currentState = 589;
 				break;
 			}
 			case 589: {
-				stateStack.Push(590);
-				goto case 428;
+				PopContext();
+				goto case 590;
 			}
 			case 590: {
 				if (la == null) { currentState = 590; break; }
-				Expect(38, la); // ")"
+				Expect(37, la); // "("
 				currentState = 591;
 				break;
 			}
 			case 591: {
-				if (la == null) { currentState = 591; break; }
+				stateStack.Push(592);
+				goto case 428;
+			}
+			case 592: {
+				if (la == null) { currentState = 592; break; }
+				Expect(38, la); // ")"
+				currentState = 593;
+				break;
+			}
+			case 593: {
+				if (la == null) { currentState = 593; break; }
 				if (la.kind == 63) {
-					currentState = 595;
+					currentState = 597;
 					break;
 				} else {
-					goto case 592;
+					goto case 594;
 				}
 			}
-			case 592: {
-				stateStack.Push(593);
+			case 594: {
+				stateStack.Push(595);
 				goto case 259;
 			}
-			case 593: {
-				if (la == null) { currentState = 593; break; }
+			case 595: {
+				if (la == null) { currentState = 595; break; }
 				Expect(113, la); // "End"
-				currentState = 594;
+				currentState = 596;
 				break;
 			}
-			case 594: {
-				if (la == null) { currentState = 594; break; }
+			case 596: {
+				if (la == null) { currentState = 596; break; }
 				Expect(172, la); // "Operator"
 				currentState = 23;
 				break;
 			}
-			case 595: {
+			case 597: {
 				PushContext(Context.Type, la, t);
-				goto case 596;
+				goto case 598;
 			}
-			case 596: {
-				if (la == null) { currentState = 596; break; }
+			case 598: {
+				if (la == null) { currentState = 598; break; }
 				if (la.kind == 40) {
-					stateStack.Push(596);
-					goto case 441;
+					stateStack.Push(598);
+					goto case 443;
 				} else {
-					stateStack.Push(597);
+					stateStack.Push(599);
 					goto case 37;
 				}
 			}
-			case 597: {
+			case 599: {
 				PopContext();
-				goto case 592;
+				goto case 594;
 			}
-			case 598: {
-				if (la == null) { currentState = 598; break; }
+			case 600: {
+				if (la == null) { currentState = 600; break; }
 				Expect(186, la); // "Property"
-				currentState = 599;
+				currentState = 601;
 				break;
 			}
-			case 599: {
+			case 601: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(600);
+				stateStack.Push(602);
 				goto case 205;
 			}
-			case 600: {
+			case 602: {
 				PopContext();
-				goto case 601;
+				goto case 603;
 			}
-			case 601: {
-				if (la == null) { currentState = 601; break; }
+			case 603: {
+				if (la == null) { currentState = 603; break; }
 				if (la.kind == 37) {
-					stateStack.Push(602);
+					stateStack.Push(604);
 					goto case 424;
 				} else {
-					goto case 602;
+					goto case 604;
 				}
 			}
-			case 602: {
-				if (la == null) { currentState = 602; break; }
+			case 604: {
+				if (la == null) { currentState = 604; break; }
 				if (la.kind == 63) {
-					currentState = 632;
+					currentState = 634;
 					break;
 				} else {
-					goto case 603;
+					goto case 605;
 				}
 			}
-			case 603: {
-				if (la == null) { currentState = 603; break; }
+			case 605: {
+				if (la == null) { currentState = 605; break; }
 				if (la.kind == 136) {
-					currentState = 627;
+					currentState = 629;
 					break;
 				} else {
-					goto case 604;
+					goto case 606;
 				}
 			}
-			case 604: {
-				if (la == null) { currentState = 604; break; }
+			case 606: {
+				if (la == null) { currentState = 606; break; }
 				if (la.kind == 20) {
-					currentState = 626;
+					currentState = 628;
 					break;
 				} else {
-					goto case 605;
+					goto case 607;
 				}
 			}
-			case 605: {
-				stateStack.Push(606);
+			case 607: {
+				stateStack.Push(608);
 				goto case 23;
 			}
-			case 606: {
+			case 608: {
 				PopContext();
-				goto case 607;
+				goto case 609;
 			}
-			case 607: {
-				if (la == null) { currentState = 607; break; }
+			case 609: {
+				if (la == null) { currentState = 609; break; }
 				if (la.kind == 40) {
-					stateStack.Push(607);
-					goto case 441;
+					stateStack.Push(609);
+					goto case 443;
 				} else {
-					goto case 608;
+					goto case 610;
 				}
 			}
-			case 608: {
-				if (la == null) { currentState = 608; break; }
-				if (set[151].Get(la.kind)) {
-					currentState = 625;
+			case 610: {
+				if (la == null) { currentState = 610; break; }
+				if (set[153].Get(la.kind)) {
+					currentState = 627;
 					break;
 				} else {
 					if (la.kind == 128 || la.kind == 198) {
 						PushContext(Context.Member, la, t);
-						goto case 609;
+						goto case 611;
 					} else {
 						currentState = stateStack.Pop();
 						goto switchlbl;
 					}
 				}
 			}
-			case 609: {
-				if (la == null) { currentState = 609; break; }
+			case 611: {
+				if (la == null) { currentState = 611; break; }
 				if (la.kind == 128) {
-					currentState = 610;
+					currentState = 612;
 					break;
 				} else {
 					if (la.kind == 198) {
-						currentState = 610;
+						currentState = 612;
 						break;
 					} else {
 						Error(la);
-						goto case 610;
+						goto case 612;
 					}
 				}
 			}
-			case 610: {
-				if (la == null) { currentState = 610; break; }
+			case 612: {
+				if (la == null) { currentState = 612; break; }
 				if (la.kind == 37) {
-					stateStack.Push(611);
+					stateStack.Push(613);
 					goto case 424;
 				} else {
-					goto case 611;
+					goto case 613;
 				}
 			}
-			case 611: {
-				stateStack.Push(612);
+			case 613: {
+				stateStack.Push(614);
 				goto case 259;
 			}
-			case 612: {
-				if (la == null) { currentState = 612; break; }
+			case 614: {
+				if (la == null) { currentState = 614; break; }
 				Expect(113, la); // "End"
-				currentState = 613;
+				currentState = 615;
 				break;
 			}
-			case 613: {
-				if (la == null) { currentState = 613; break; }
+			case 615: {
+				if (la == null) { currentState = 615; break; }
 				if (la.kind == 128) {
-					currentState = 614;
+					currentState = 616;
 					break;
 				} else {
 					if (la.kind == 198) {
-						currentState = 614;
+						currentState = 616;
 						break;
 					} else {
 						Error(la);
-						goto case 614;
+						goto case 616;
 					}
 				}
 			}
-			case 614: {
-				stateStack.Push(615);
+			case 616: {
+				stateStack.Push(617);
 				goto case 23;
 			}
-			case 615: {
-				if (la == null) { currentState = 615; break; }
-				if (set[109].Get(la.kind)) {
-					goto case 618;
+			case 617: {
+				if (la == null) { currentState = 617; break; }
+				if (set[110].Get(la.kind)) {
+					goto case 620;
 				} else {
-					goto case 616;
+					goto case 618;
 				}
 			}
-			case 616: {
-				if (la == null) { currentState = 616; break; }
+			case 618: {
+				if (la == null) { currentState = 618; break; }
 				Expect(113, la); // "End"
-				currentState = 617;
+				currentState = 619;
 				break;
 			}
-			case 617: {
-				if (la == null) { currentState = 617; break; }
+			case 619: {
+				if (la == null) { currentState = 619; break; }
 				Expect(186, la); // "Property"
 				currentState = 23;
 				break;
 			}
-			case 618: {
-				if (la == null) { currentState = 618; break; }
+			case 620: {
+				if (la == null) { currentState = 620; break; }
 				if (la.kind == 40) {
-					stateStack.Push(618);
-					goto case 441;
+					stateStack.Push(620);
+					goto case 443;
 				} else {
-					goto case 619;
+					goto case 621;
 				}
 			}
-			case 619: {
-				if (la == null) { currentState = 619; break; }
-				if (set[151].Get(la.kind)) {
-					currentState = 619;
+			case 621: {
+				if (la == null) { currentState = 621; break; }
+				if (set[153].Get(la.kind)) {
+					currentState = 621;
 					break;
 				} else {
 					if (la.kind == 128) {
-						currentState = 620;
+						currentState = 622;
 						break;
 					} else {
 						if (la.kind == 198) {
-							currentState = 620;
+							currentState = 622;
 							break;
 						} else {
 							Error(la);
-							goto case 620;
+							goto case 622;
 						}
 					}
 				}
 			}
-			case 620: {
-				if (la == null) { currentState = 620; break; }
+			case 622: {
+				if (la == null) { currentState = 622; break; }
 				if (la.kind == 37) {
-					stateStack.Push(621);
+					stateStack.Push(623);
 					goto case 424;
 				} else {
-					goto case 621;
+					goto case 623;
 				}
 			}
-			case 621: {
-				stateStack.Push(622);
+			case 623: {
+				stateStack.Push(624);
 				goto case 259;
 			}
-			case 622: {
-				if (la == null) { currentState = 622; break; }
+			case 624: {
+				if (la == null) { currentState = 624; break; }
 				Expect(113, la); // "End"
-				currentState = 623;
+				currentState = 625;
 				break;
 			}
-			case 623: {
-				if (la == null) { currentState = 623; break; }
+			case 625: {
+				if (la == null) { currentState = 625; break; }
 				if (la.kind == 128) {
-					currentState = 624;
+					currentState = 626;
 					break;
 				} else {
 					if (la.kind == 198) {
-						currentState = 624;
+						currentState = 626;
 						break;
 					} else {
 						Error(la);
-						goto case 624;
+						goto case 626;
 					}
 				}
 			}
-			case 624: {
-				stateStack.Push(616);
+			case 626: {
+				stateStack.Push(618);
 				goto case 23;
 			}
-			case 625: {
+			case 627: {
 				SetIdentifierExpected(la);
-				goto case 608;
+				goto case 610;
 			}
-			case 626: {
-				stateStack.Push(605);
+			case 628: {
+				stateStack.Push(607);
 				goto case 55;
 			}
-			case 627: {
+			case 629: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(628);
+				stateStack.Push(630);
 				goto case 37;
 			}
-			case 628: {
+			case 630: {
 				PopContext();
-				goto case 629;
+				goto case 631;
 			}
-			case 629: {
-				if (la == null) { currentState = 629; break; }
+			case 631: {
+				if (la == null) { currentState = 631; break; }
 				if (la.kind == 22) {
-					currentState = 630;
+					currentState = 632;
 					break;
 				} else {
-					goto case 604;
+					goto case 606;
 				}
 			}
-			case 630: {
+			case 632: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(631);
+				stateStack.Push(633);
 				goto case 37;
 			}
-			case 631: {
+			case 633: {
 				PopContext();
-				goto case 629;
+				goto case 631;
 			}
-			case 632: {
+			case 634: {
 				PushContext(Context.Type, la, t);
-				goto case 633;
+				goto case 635;
 			}
-			case 633: {
-				if (la == null) { currentState = 633; break; }
+			case 635: {
+				if (la == null) { currentState = 635; break; }
 				if (la.kind == 40) {
-					stateStack.Push(633);
-					goto case 441;
+					stateStack.Push(635);
+					goto case 443;
 				} else {
 					if (la.kind == 162) {
-						stateStack.Push(634);
+						stateStack.Push(636);
 						goto case 85;
 					} else {
 						if (set[16].Get(la.kind)) {
-							stateStack.Push(634);
+							stateStack.Push(636);
 							goto case 37;
 						} else {
 							Error(la);
-							goto case 634;
+							goto case 636;
 						}
 					}
 				}
 			}
-			case 634: {
+			case 636: {
 				PopContext();
-				goto case 603;
+				goto case 605;
 			}
-			case 635: {
-				if (la == null) { currentState = 635; break; }
+			case 637: {
+				if (la == null) { currentState = 637; break; }
 				Expect(98, la); // "Custom"
-				currentState = 636;
+				currentState = 638;
 				break;
 			}
-			case 636: {
-				stateStack.Push(637);
-				goto case 647;
+			case 638: {
+				stateStack.Push(639);
+				goto case 649;
 			}
-			case 637: {
-				if (la == null) { currentState = 637; break; }
-				if (set[114].Get(la.kind)) {
-					goto case 639;
+			case 639: {
+				if (la == null) { currentState = 639; break; }
+				if (set[115].Get(la.kind)) {
+					goto case 641;
 				} else {
 					Expect(113, la); // "End"
-					currentState = 638;
+					currentState = 640;
 					break;
 				}
 			}
-			case 638: {
-				if (la == null) { currentState = 638; break; }
+			case 640: {
+				if (la == null) { currentState = 640; break; }
 				Expect(119, la); // "Event"
 				currentState = 23;
 				break;
 			}
-			case 639: {
-				if (la == null) { currentState = 639; break; }
+			case 641: {
+				if (la == null) { currentState = 641; break; }
 				if (la.kind == 40) {
-					stateStack.Push(639);
-					goto case 441;
+					stateStack.Push(641);
+					goto case 443;
 				} else {
 					if (la.kind == 56) {
-						currentState = 640;
+						currentState = 642;
 						break;
 					} else {
 						if (la.kind == 193) {
-							currentState = 640;
+							currentState = 642;
 							break;
 						} else {
 							if (la.kind == 189) {
-								currentState = 640;
+								currentState = 642;
 								break;
 							} else {
 								Error(la);
-								goto case 640;
+								goto case 642;
 							}
 						}
 					}
 				}
 			}
-			case 640: {
-				if (la == null) { currentState = 640; break; }
-				Expect(37, la); // "("
-				currentState = 641;
-				break;
-			}
-			case 641: {
-				stateStack.Push(642);
-				goto case 428;
-			}
 			case 642: {
 				if (la == null) { currentState = 642; break; }
-				Expect(38, la); // ")"
+				Expect(37, la); // "("
 				currentState = 643;
 				break;
 			}
 			case 643: {
 				stateStack.Push(644);
-				goto case 259;
+				goto case 428;
 			}
 			case 644: {
 				if (la == null) { currentState = 644; break; }
-				Expect(113, la); // "End"
+				Expect(38, la); // ")"
 				currentState = 645;
 				break;
 			}
 			case 645: {
-				if (la == null) { currentState = 645; break; }
+				stateStack.Push(646);
+				goto case 259;
+			}
+			case 646: {
+				if (la == null) { currentState = 646; break; }
+				Expect(113, la); // "End"
+				currentState = 647;
+				break;
+			}
+			case 647: {
+				if (la == null) { currentState = 647; break; }
 				if (la.kind == 56) {
-					currentState = 646;
+					currentState = 648;
 					break;
 				} else {
 					if (la.kind == 193) {
-						currentState = 646;
+						currentState = 648;
 						break;
 					} else {
 						if (la.kind == 189) {
-							currentState = 646;
+							currentState = 648;
 							break;
 						} else {
 							Error(la);
-							goto case 646;
+							goto case 648;
 						}
 					}
 				}
 			}
-			case 646: {
-				stateStack.Push(637);
+			case 648: {
+				stateStack.Push(639);
 				goto case 23;
 			}
-			case 647: {
-				if (la == null) { currentState = 647; break; }
+			case 649: {
+				if (la == null) { currentState = 649; break; }
 				Expect(119, la); // "Event"
-				currentState = 648;
+				currentState = 650;
 				break;
 			}
-			case 648: {
+			case 650: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(649);
+				stateStack.Push(651);
 				goto case 205;
 			}
-			case 649: {
+			case 651: {
 				PopContext();
-				goto case 650;
+				goto case 652;
 			}
-			case 650: {
-				if (la == null) { currentState = 650; break; }
+			case 652: {
+				if (la == null) { currentState = 652; break; }
 				if (la.kind == 63) {
-					currentState = 657;
+					currentState = 659;
 					break;
 				} else {
-					if (set[152].Get(la.kind)) {
+					if (set[154].Get(la.kind)) {
 						if (la.kind == 37) {
-							stateStack.Push(651);
+							stateStack.Push(653);
 							goto case 424;
 						} else {
-							goto case 651;
+							goto case 653;
 						}
 					} else {
 						Error(la);
-						goto case 651;
+						goto case 653;
 					}
 				}
 			}
-			case 651: {
-				if (la == null) { currentState = 651; break; }
+			case 653: {
+				if (la == null) { currentState = 653; break; }
 				if (la.kind == 136) {
-					currentState = 652;
+					currentState = 654;
 					break;
 				} else {
 					goto case 23;
 				}
 			}
-			case 652: {
+			case 654: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(653);
+				stateStack.Push(655);
 				goto case 37;
 			}
-			case 653: {
+			case 655: {
 				PopContext();
-				goto case 654;
+				goto case 656;
 			}
-			case 654: {
-				if (la == null) { currentState = 654; break; }
+			case 656: {
+				if (la == null) { currentState = 656; break; }
 				if (la.kind == 22) {
-					currentState = 655;
+					currentState = 657;
 					break;
 				} else {
 					goto case 23;
 				}
 			}
-			case 655: {
+			case 657: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(656);
+				stateStack.Push(658);
 				goto case 37;
 			}
-			case 656: {
+			case 658: {
 				PopContext();
-				goto case 654;
+				goto case 656;
 			}
-			case 657: {
+			case 659: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(658);
+				stateStack.Push(660);
 				goto case 37;
 			}
-			case 658: {
+			case 660: {
 				PopContext();
-				goto case 651;
+				goto case 653;
 			}
-			case 659: {
-				if (la == null) { currentState = 659; break; }
+			case 661: {
+				if (la == null) { currentState = 661; break; }
 				Expect(101, la); // "Declare"
-				currentState = 660;
+				currentState = 662;
 				break;
 			}
-			case 660: {
-				if (la == null) { currentState = 660; break; }
+			case 662: {
+				if (la == null) { currentState = 662; break; }
 				if (la.kind == 62 || la.kind == 66 || la.kind == 223) {
-					currentState = 661;
+					currentState = 663;
 					break;
 				} else {
-					goto case 661;
+					goto case 663;
 				}
 			}
-			case 661: {
-				if (la == null) { currentState = 661; break; }
+			case 663: {
+				if (la == null) { currentState = 663; break; }
 				if (la.kind == 210) {
-					currentState = 662;
+					currentState = 664;
 					break;
 				} else {
 					if (la.kind == 127) {
-						currentState = 662;
+						currentState = 664;
 						break;
 					} else {
 						Error(la);
-						goto case 662;
+						goto case 664;
 					}
 				}
 			}
-			case 662: {
+			case 664: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(663);
+				stateStack.Push(665);
 				goto case 205;
 			}
-			case 663: {
+			case 665: {
 				PopContext();
-				goto case 664;
+				goto case 666;
 			}
-			case 664: {
-				if (la == null) { currentState = 664; break; }
+			case 666: {
+				if (la == null) { currentState = 666; break; }
 				Expect(149, la); // "Lib"
-				currentState = 665;
+				currentState = 667;
 				break;
 			}
-			case 665: {
-				if (la == null) { currentState = 665; break; }
+			case 667: {
+				if (la == null) { currentState = 667; break; }
 				Expect(3, la); // LiteralString
-				currentState = 666;
+				currentState = 668;
 				break;
 			}
-			case 666: {
-				if (la == null) { currentState = 666; break; }
+			case 668: {
+				if (la == null) { currentState = 668; break; }
 				if (la.kind == 59) {
-					currentState = 671;
+					currentState = 673;
 					break;
 				} else {
-					goto case 667;
+					goto case 669;
 				}
 			}
-			case 667: {
-				if (la == null) { currentState = 667; break; }
+			case 669: {
+				if (la == null) { currentState = 669; break; }
 				if (la.kind == 37) {
-					stateStack.Push(668);
+					stateStack.Push(670);
 					goto case 424;
 				} else {
-					goto case 668;
+					goto case 670;
 				}
 			}
-			case 668: {
-				if (la == null) { currentState = 668; break; }
+			case 670: {
+				if (la == null) { currentState = 670; break; }
 				if (la.kind == 63) {
-					currentState = 669;
+					currentState = 671;
 					break;
 				} else {
 					goto case 23;
 				}
 			}
-			case 669: {
+			case 671: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(670);
+				stateStack.Push(672);
 				goto case 37;
 			}
-			case 670: {
+			case 672: {
 				PopContext();
 				goto case 23;
 			}
-			case 671: {
-				if (la == null) { currentState = 671; break; }
+			case 673: {
+				if (la == null) { currentState = 673; break; }
 				Expect(3, la); // LiteralString
-				currentState = 667;
+				currentState = 669;
 				break;
 			}
-			case 672: {
-				if (la == null) { currentState = 672; break; }
+			case 674: {
+				if (la == null) { currentState = 674; break; }
 				if (la.kind == 210) {
-					currentState = 673;
+					currentState = 675;
 					break;
 				} else {
 					if (la.kind == 127) {
-						currentState = 673;
+						currentState = 675;
 						break;
 					} else {
 						Error(la);
-						goto case 673;
+						goto case 675;
 					}
 				}
 			}
-			case 673: {
+			case 675: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				goto case 674;
+				goto case 676;
 			}
-			case 674: {
-				if (la == null) { currentState = 674; break; }
-				currentState = 675;
+			case 676: {
+				if (la == null) { currentState = 676; break; }
+				currentState = 677;
 				break;
 			}
-			case 675: {
+			case 677: {
 				PopContext();
-				goto case 676;
+				goto case 678;
 			}
-			case 676: {
-				if (la == null) { currentState = 676; break; }
+			case 678: {
+				if (la == null) { currentState = 678; break; }
 				if (la.kind == 37) {
-					currentState = 686;
+					currentState = 688;
 					break;
 				} else {
 					if (la.kind == 63) {
-						currentState = 684;
+						currentState = 686;
 						break;
 					} else {
-						goto case 677;
+						goto case 679;
 					}
 				}
 			}
-			case 677: {
-				if (la == null) { currentState = 677; break; }
+			case 679: {
+				if (la == null) { currentState = 679; break; }
 				if (la.kind == 134 || la.kind == 136) {
-					currentState = 681;
+					currentState = 683;
 					break;
 				} else {
-					goto case 678;
+					goto case 680;
 				}
 			}
-			case 678: {
-				stateStack.Push(679);
+			case 680: {
+				stateStack.Push(681);
 				goto case 259;
 			}
-			case 679: {
-				if (la == null) { currentState = 679; break; }
+			case 681: {
+				if (la == null) { currentState = 681; break; }
 				Expect(113, la); // "End"
-				currentState = 680;
+				currentState = 682;
 				break;
 			}
-			case 680: {
-				if (la == null) { currentState = 680; break; }
+			case 682: {
+				if (la == null) { currentState = 682; break; }
 				if (la.kind == 210) {
 					currentState = 23;
 					break;
@@ -7916,129 +7950,129 @@ partial class ExpressionFinder {
 						currentState = 23;
 						break;
 					} else {
-						goto case 528;
+						goto case 530;
 					}
 				}
 			}
-			case 681: {
-				if (la == null) { currentState = 681; break; }
+			case 683: {
+				if (la == null) { currentState = 683; break; }
 				if (la.kind == 153 || la.kind == 158 || la.kind == 159) {
-					currentState = 683;
+					currentState = 685;
 					break;
 				} else {
-					goto case 682;
+					goto case 684;
 				}
 			}
-			case 682: {
-				stateStack.Push(678);
+			case 684: {
+				stateStack.Push(680);
 				goto case 37;
 			}
-			case 683: {
-				if (la == null) { currentState = 683; break; }
+			case 685: {
+				if (la == null) { currentState = 685; break; }
 				Expect(26, la); // "."
-				currentState = 682;
+				currentState = 684;
 				break;
 			}
-			case 684: {
+			case 686: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(685);
+				stateStack.Push(687);
 				goto case 37;
 			}
-			case 685: {
+			case 687: {
 				PopContext();
-				goto case 677;
+				goto case 679;
 			}
-			case 686: {
+			case 688: {
 				SetIdentifierExpected(la);
-				goto case 687;
+				goto case 689;
 			}
-			case 687: {
-				if (la == null) { currentState = 687; break; }
-				if (set[150].Get(la.kind)) {
+			case 689: {
+				if (la == null) { currentState = 689; break; }
+				if (set[152].Get(la.kind)) {
 					if (la.kind == 169) {
-						currentState = 689;
+						currentState = 691;
 						break;
 					} else {
 						if (set[77].Get(la.kind)) {
-							stateStack.Push(688);
+							stateStack.Push(690);
 							goto case 428;
 						} else {
 							Error(la);
-							goto case 688;
+							goto case 690;
 						}
 					}
 				} else {
-					goto case 688;
+					goto case 690;
 				}
 			}
-			case 688: {
-				if (la == null) { currentState = 688; break; }
+			case 690: {
+				if (la == null) { currentState = 690; break; }
 				Expect(38, la); // ")"
-				currentState = 676;
+				currentState = 678;
 				break;
 			}
-			case 689: {
-				stateStack.Push(688);
-				goto case 498;
+			case 691: {
+				stateStack.Push(690);
+				goto case 500;
 			}
-			case 690: {
-				stateStack.Push(691);
+			case 692: {
+				stateStack.Push(693);
 				SetIdentifierExpected(la);
-				goto case 692;
+				goto case 694;
 			}
-			case 691: {
-				if (la == null) { currentState = 691; break; }
+			case 693: {
+				if (la == null) { currentState = 693; break; }
 				if (la.kind == 22) {
-					currentState = 690;
+					currentState = 692;
 					break;
 				} else {
 					goto case 23;
 				}
 			}
-			case 692: {
-				if (la == null) { currentState = 692; break; }
+			case 694: {
+				if (la == null) { currentState = 694; break; }
 				if (la.kind == 88) {
-					currentState = 693;
+					currentState = 695;
 					break;
 				} else {
-					goto case 693;
+					goto case 695;
 				}
 			}
-			case 693: {
+			case 695: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				stateStack.Push(694);
-				goto case 704;
+				stateStack.Push(696);
+				goto case 706;
 			}
-			case 694: {
+			case 696: {
 				PopContext();
-				goto case 695;
+				goto case 697;
 			}
-			case 695: {
-				if (la == null) { currentState = 695; break; }
+			case 697: {
+				if (la == null) { currentState = 697; break; }
 				if (la.kind == 33) {
-					currentState = 696;
+					currentState = 698;
 					break;
 				} else {
-					goto case 696;
+					goto case 698;
 				}
 			}
-			case 696: {
-				if (la == null) { currentState = 696; break; }
+			case 698: {
+				if (la == null) { currentState = 698; break; }
 				if (la.kind == 37) {
-					currentState = 701;
+					currentState = 703;
 					break;
 				} else {
 					if (la.kind == 63) {
-						currentState = 698;
+						currentState = 700;
 						break;
 					} else {
-						goto case 697;
+						goto case 699;
 					}
 				}
 			}
-			case 697: {
-				if (la == null) { currentState = 697; break; }
+			case 699: {
+				if (la == null) { currentState = 699; break; }
 				if (la.kind == 20) {
 					currentState = 55;
 					break;
@@ -8047,56 +8081,56 @@ partial class ExpressionFinder {
 					goto switchlbl;
 				}
 			}
-			case 698: {
+			case 700: {
 				PushContext(Context.Type, la, t);
-				goto case 699;
+				goto case 701;
 			}
-			case 699: {
-				if (la == null) { currentState = 699; break; }
+			case 701: {
+				if (la == null) { currentState = 701; break; }
 				if (la.kind == 162) {
-					stateStack.Push(700);
+					stateStack.Push(702);
 					goto case 85;
 				} else {
 					if (set[16].Get(la.kind)) {
-						stateStack.Push(700);
+						stateStack.Push(702);
 						goto case 37;
 					} else {
 						Error(la);
-						goto case 700;
+						goto case 702;
 					}
 				}
 			}
-			case 700: {
+			case 702: {
 				PopContext();
-				goto case 697;
+				goto case 699;
 			}
-			case 701: {
+			case 703: {
 				nextTokenIsPotentialStartOfExpression = true;
-				goto case 702;
+				goto case 704;
 			}
-			case 702: {
-				if (la == null) { currentState = 702; break; }
+			case 704: {
+				if (la == null) { currentState = 704; break; }
 				if (set[23].Get(la.kind)) {
-					stateStack.Push(703);
+					stateStack.Push(705);
 					goto case 55;
 				} else {
-					goto case 703;
+					goto case 705;
 				}
 			}
-			case 703: {
-				if (la == null) { currentState = 703; break; }
+			case 705: {
+				if (la == null) { currentState = 705; break; }
 				if (la.kind == 22) {
-					currentState = 701;
+					currentState = 703;
 					break;
 				} else {
 					Expect(38, la); // ")"
-					currentState = 696;
+					currentState = 698;
 					break;
 				}
 			}
-			case 704: {
-				if (la == null) { currentState = 704; break; }
-				if (set[136].Get(la.kind)) {
+			case 706: {
+				if (la == null) { currentState = 706; break; }
+				if (set[138].Get(la.kind)) {
 					currentState = stateStack.Pop();
 					break;
 				} else {
@@ -8111,249 +8145,285 @@ partial class ExpressionFinder {
 					}
 				}
 			}
-			case 705: {
+			case 707: {
 				isMissingModifier = false;
-				goto case 579;
+				goto case 581;
 			}
-			case 706: {
-				if (la == null) { currentState = 706; break; }
+			case 708: {
+				if (la == null) { currentState = 708; break; }
 				Expect(136, la); // "Implements"
-				currentState = 707;
+				currentState = 709;
 				break;
 			}
-			case 707: {
+			case 709: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(708);
+				stateStack.Push(710);
 				goto case 37;
 			}
-			case 708: {
+			case 710: {
 				PopContext();
-				goto case 709;
+				goto case 711;
 			}
-			case 709: {
-				if (la == null) { currentState = 709; break; }
+			case 711: {
+				if (la == null) { currentState = 711; break; }
 				if (la.kind == 22) {
-					currentState = 710;
+					currentState = 712;
 					break;
 				} else {
-					stateStack.Push(571);
+					stateStack.Push(573);
 					goto case 23;
 				}
 			}
-			case 710: {
+			case 712: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(711);
+				stateStack.Push(713);
 				goto case 37;
 			}
-			case 711: {
+			case 713: {
 				PopContext();
-				goto case 709;
+				goto case 711;
 			}
-			case 712: {
-				if (la == null) { currentState = 712; break; }
+			case 714: {
+				if (la == null) { currentState = 714; break; }
 				Expect(140, la); // "Inherits"
-				currentState = 713;
+				currentState = 715;
 				break;
 			}
-			case 713: {
+			case 715: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(714);
+				stateStack.Push(716);
 				goto case 37;
 			}
-			case 714: {
+			case 716: {
 				PopContext();
-				stateStack.Push(569);
+				stateStack.Push(571);
 				goto case 23;
 			}
-			case 715: {
-				if (la == null) { currentState = 715; break; }
+			case 717: {
+				if (la == null) { currentState = 717; break; }
 				Expect(169, la); // "Of"
-				currentState = 716;
+				currentState = 718;
 				break;
 			}
-			case 716: {
-				stateStack.Push(717);
-				goto case 498;
+			case 718: {
+				stateStack.Push(719);
+				goto case 500;
 			}
-			case 717: {
-				if (la == null) { currentState = 717; break; }
+			case 719: {
+				if (la == null) { currentState = 719; break; }
 				Expect(38, la); // ")"
-				currentState = 566;
+				currentState = 568;
 				break;
 			}
-			case 718: {
+			case 720: {
 				isMissingModifier = false;
 				goto case 28;
 			}
-			case 719: {
+			case 721: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(720);
+				stateStack.Push(722);
 				goto case 37;
 			}
-			case 720: {
+			case 722: {
 				PopContext();
-				goto case 721;
+				goto case 723;
 			}
-			case 721: {
-				if (la == null) { currentState = 721; break; }
+			case 723: {
+				if (la == null) { currentState = 723; break; }
 				if (la.kind == 22) {
-					currentState = 722;
+					currentState = 724;
 					break;
 				} else {
 					stateStack.Push(17);
 					goto case 23;
 				}
 			}
-			case 722: {
+			case 724: {
 				PushContext(Context.Type, la, t);
-				stateStack.Push(723);
+				stateStack.Push(725);
 				goto case 37;
 			}
-			case 723: {
+			case 725: {
 				PopContext();
-				goto case 721;
+				goto case 723;
 			}
-			case 724: {
-				if (la == null) { currentState = 724; break; }
+			case 726: {
+				if (la == null) { currentState = 726; break; }
 				Expect(169, la); // "Of"
-				currentState = 725;
+				currentState = 727;
 				break;
 			}
-			case 725: {
-				stateStack.Push(726);
-				goto case 498;
+			case 727: {
+				stateStack.Push(728);
+				goto case 500;
 			}
-			case 726: {
-				if (la == null) { currentState = 726; break; }
+			case 728: {
+				if (la == null) { currentState = 728; break; }
 				Expect(38, la); // ")"
 				currentState = 14;
 				break;
 			}
-			case 727: {
+			case 729: {
 				PushContext(Context.Identifier, la, t);
 				SetIdentifierExpected(la);
-				goto case 728;
+				goto case 730;
 			}
-			case 728: {
-				if (la == null) { currentState = 728; break; }
+			case 730: {
+				if (la == null) { currentState = 730; break; }
 				if (set[49].Get(la.kind)) {
-					currentState = 728;
+					currentState = 730;
 					break;
 				} else {
 					PopContext();
-					stateStack.Push(729);
+					stateStack.Push(731);
 					goto case 23;
 				}
 			}
-			case 729: {
-				if (la == null) { currentState = 729; break; }
+			case 731: {
+				if (la == null) { currentState = 731; break; }
 				if (set[3].Get(la.kind)) {
-					stateStack.Push(729);
+					stateStack.Push(731);
 					goto case 5;
 				} else {
 					Expect(113, la); // "End"
-					currentState = 730;
+					currentState = 732;
 					break;
 				}
 			}
-			case 730: {
-				if (la == null) { currentState = 730; break; }
+			case 732: {
+				if (la == null) { currentState = 732; break; }
 				Expect(160, la); // "Namespace"
 				currentState = 23;
 				break;
 			}
-			case 731: {
-				if (la == null) { currentState = 731; break; }
+			case 733: {
+				if (la == null) { currentState = 733; break; }
 				Expect(137, la); // "Imports"
-				currentState = 732;
+				currentState = 734;
 				break;
 			}
-			case 732: {
+			case 734: {
 				PushContext(Context.Importable, la, t);
 				nextTokenIsStartOfImportsOrAccessExpression = true;	
-				goto case 733;
+				goto case 735;
 			}
-			case 733: {
-				if (la == null) { currentState = 733; break; }
-				if (set[153].Get(la.kind)) {
-					currentState = 739;
+			case 735: {
+				if (la == null) { currentState = 735; break; }
+				if (set[155].Get(la.kind)) {
+					currentState = 747;
 					break;
 				} else {
-					if (la.kind == 10) {
-						currentState = 735;
-						break;
-					} else {
-						Error(la);
-						goto case 734;
-					}
+					goto case 736;
 				}
 			}
-			case 734: {
-				PopContext();
-				goto case 23;
-			}
-			case 735: {
-				stateStack.Push(736);
-				goto case 205;
-			}
 			case 736: {
 				if (la == null) { currentState = 736; break; }
-				Expect(20, la); // "="
-				currentState = 737;
-				break;
+				if (la.kind == 10) {
+					currentState = 743;
+					break;
+				} else {
+					Error(la);
+					goto case 737;
+				}
 			}
 			case 737: {
 				if (la == null) { currentState = 737; break; }
-				Expect(3, la); // LiteralString
-				currentState = 738;
-				break;
+				if (la.kind == 22) {
+					currentState = 738;
+					break;
+				} else {
+					PopContext();
+					goto case 23;
+				}
 			}
 			case 738: {
-				if (la == null) { currentState = 738; break; }
-				Expect(11, la); // XmlCloseTag
-				currentState = 734;
-				break;
+				nextTokenIsStartOfImportsOrAccessExpression = true;	
+				goto case 739;
 			}
 			case 739: {
 				if (la == null) { currentState = 739; break; }
-				if (la.kind == 37) {
-					stateStack.Push(739);
-					goto case 42;
+				if (set[155].Get(la.kind)) {
+					currentState = 740;
+					break;
 				} else {
-					if (la.kind == 20 || la.kind == 26) {
-						currentState = 740;
-						break;
-					} else {
-						goto case 734;
-					}
+					goto case 736;
 				}
 			}
 			case 740: {
-				stateStack.Push(734);
-				goto case 37;
+				if (la == null) { currentState = 740; break; }
+				if (la.kind == 37) {
+					stateStack.Push(740);
+					goto case 42;
+				} else {
+					goto case 741;
+				}
 			}
 			case 741: {
 				if (la == null) { currentState = 741; break; }
+				if (la.kind == 20 || la.kind == 26) {
+					currentState = 742;
+					break;
+				} else {
+					goto case 737;
+				}
+			}
+			case 742: {
+				stateStack.Push(737);
+				goto case 37;
+			}
+			case 743: {
+				stateStack.Push(744);
+				goto case 205;
+			}
+			case 744: {
+				if (la == null) { currentState = 744; break; }
+				Expect(20, la); // "="
+				currentState = 745;
+				break;
+			}
+			case 745: {
+				if (la == null) { currentState = 745; break; }
+				Expect(3, la); // LiteralString
+				currentState = 746;
+				break;
+			}
+			case 746: {
+				if (la == null) { currentState = 746; break; }
+				Expect(11, la); // XmlCloseTag
+				currentState = 737;
+				break;
+			}
+			case 747: {
+				if (la == null) { currentState = 747; break; }
+				if (la.kind == 37) {
+					stateStack.Push(747);
+					goto case 42;
+				} else {
+					goto case 741;
+				}
+			}
+			case 748: {
+				if (la == null) { currentState = 748; break; }
 				Expect(173, la); // "Option"
-				currentState = 742;
+				currentState = 749;
 				break;
 			}
-			case 742: {
-				if (la == null) { currentState = 742; break; }
+			case 749: {
+				if (la == null) { currentState = 749; break; }
 				if (la.kind == 121 || la.kind == 139 || la.kind == 207) {
-					currentState = 744;
+					currentState = 751;
 					break;
 				} else {
 					if (la.kind == 87) {
-						currentState = 743;
+						currentState = 750;
 						break;
 					} else {
-						goto case 528;
+						goto case 530;
 					}
 				}
 			}
-			case 743: {
-				if (la == null) { currentState = 743; break; }
+			case 750: {
+				if (la == null) { currentState = 750; break; }
 				if (la.kind == 213) {
 					currentState = 23;
 					break;
@@ -8362,12 +8432,12 @@ partial class ExpressionFinder {
 						currentState = 23;
 						break;
 					} else {
-						goto case 528;
+						goto case 530;
 					}
 				}
 			}
-			case 744: {
-				if (la == null) { currentState = 744; break; }
+			case 751: {
+				if (la == null) { currentState = 751; break; }
 				if (la.kind == 170 || la.kind == 171) {
 					currentState = 23;
 					break;
@@ -8475,7 +8545,8 @@ partial class ExpressionFinder {
 		new BitArray(new int[] {4, 1140851008, 8388975, 1108347140, 821280, 21316608, -2144335872, 65}),
 		new BitArray(new int[] {4, 1140850944, 8388975, 1108347140, 821280, 21316608, -2144335872, 65}),
 		new BitArray(new int[] {4, 1140850688, 8388975, 1108347140, 821280, 21316608, -2144335872, 65}),
-		new BitArray(new int[] {5242880, -2147483584, 0, 0, 0, 0, 0, 0}),
+		new BitArray(new int[] {5242880, -2147483550, 0, 0, 0, 0, 0, 0}),
+		new BitArray(new int[] {5242880, -2147483552, 0, 0, 0, 0, 0, 0}),
 		new BitArray(new int[] {-2, -1, -3, -1, -134217729, -1, -1, -1}),
 		new BitArray(new int[] {7, 1157628162, 26477055, -493212676, 948758565, 2147308999, -533262382, 3395}),
 		new BitArray(new int[] {918528, 0, 0, 0, 0, 0, 0, 0}),
@@ -8523,7 +8594,8 @@ partial class ExpressionFinder {
 		new BitArray(new int[] {7340034, -2147483616, 0, 0, 0, 0, 0, 0}),
 		new BitArray(new int[] {0, 256, 1048576, 537526400, 402669568, 444596289, 131200, 0}),
 		new BitArray(new int[] {1028, 1140850688, 8650975, 1108355356, 9218084, 17106176, -533656048, 67}),
-		new BitArray(new int[] {70254594, 32, 0, 0, 0, 0, 0, 0}),
+		new BitArray(new int[] {74448898, 32, 0, 0, 0, 0, 0, 0}),
+		new BitArray(new int[] {74448898, 0, 0, 0, 0, 0, 0, 0}),
 		new BitArray(new int[] {0, 0, 8388608, 33554432, 2048, 0, 32768, 0}),
 		new BitArray(new int[] {2097154, 0, 0, 0, 0, 3072, 0, 0}),
 		new BitArray(new int[] {0, 0, 0, 536870912, 268435456, 444596288, 128, 0}),
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs
index 4c9cc88cc..f3ee77a93 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/SavepointEventArgs.cs
@@ -8,10 +8,10 @@ namespace ICSharpCode.NRefactory.VB.Parser
 {
 	public class SavepointEventArgs : EventArgs
 	{
-		public Location SavepointLocation { get; private set; }
+		public AstLocation SavepointLocation { get; private set; }
 		public VBLexerMemento State { get; private set; }
 		
-		public SavepointEventArgs(Location savepointLocation, VBLexerMemento state)
+		public SavepointEventArgs(AstLocation savepointLocation, VBLexerMemento state)
 		{
 			this.SavepointLocation = savepointLocation;
 			this.State = state;
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/BlankLine.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/BlankLine.cs
index 67a85ec0a..5120bd765 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/BlankLine.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/BlankLine.cs
@@ -5,15 +5,15 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB
 {
-	public class BlankLine : AbstractSpecial
-	{
-		public BlankLine(Location point) : base(point)
-		{
-		}
-		
-		public override object AcceptVisitor(ISpecialVisitor visitor, object data)
-		{
-			return visitor.Visit(this, data);
-		}
-	}
+//	public class BlankLine : AbstractSpecial
+//	{
+//		public BlankLine(Location point) : base(point)
+//		{
+//		}
+//		
+//		public override object AcceptVisitor(ISpecialVisitor visitor, object data)
+//		{
+//			return visitor.Visit(this, data);
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/Comment.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/Comment.cs
index 2bce0531c..82772f2d4 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/Comment.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/Comment.cs
@@ -5,55 +5,55 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB
 {
-	public class Comment : AbstractSpecial
-	{
-		CommentType   commentType;
-		string        comment;
-		
-		public CommentType CommentType {
-			get {
-				return commentType;
-			}
-			set {
-				commentType = value;
-			}
-		}
-		
-		public string CommentText {
-			get {
-				return comment;
-			}
-			set {
-				comment = value;
-			}
-		}
-		
-		/// <value>
-		/// Is true, when the comment is at line start or only whitespaces
-		/// between line and comment start.
-		/// </value>
-		public bool CommentStartsLine {
-			get;
-			set;
-		}
-		
-		public Comment(CommentType commentType, string comment, bool commentStartsLine, Location startPosition, Location endPosition)
-			: base(startPosition, endPosition)
-		{
-			this.commentType   = commentType;
-			this.comment       = comment;
-			this.CommentStartsLine = commentStartsLine;
-		}
-		
-		public override string ToString()
-		{
-			return String.Format("[{0}: Type = {1}, Text = {2}, Start = {3}, End = {4}]",
-			                     GetType().Name, CommentType, CommentText, StartPosition, EndPosition);
-		}
-		
-		public override object AcceptVisitor(ISpecialVisitor visitor, object data)
-		{
-			return visitor.Visit(this, data);
-		}
-	}
+//	public class Comment : AbstractSpecial
+//	{
+//		CommentType   commentType;
+//		string        comment;
+//		
+//		public CommentType CommentType {
+//			get {
+//				return commentType;
+//			}
+//			set {
+//				commentType = value;
+//			}
+//		}
+//		
+//		public string CommentText {
+//			get {
+//				return comment;
+//			}
+//			set {
+//				comment = value;
+//			}
+//		}
+//		
+//		/// <value>
+//		/// Is true, when the comment is at line start or only whitespaces
+//		/// between line and comment start.
+//		/// </value>
+//		public bool CommentStartsLine {
+//			get;
+//			set;
+//		}
+//		
+//		public Comment(CommentType commentType, string comment, bool commentStartsLine, Location startPosition, Location endPosition)
+//			: base(startPosition, endPosition)
+//		{
+//			this.commentType   = commentType;
+//			this.comment       = comment;
+//			this.CommentStartsLine = commentStartsLine;
+//		}
+//		
+//		public override string ToString()
+//		{
+//			return String.Format("[{0}: Type = {1}, Text = {2}, Start = {3}, End = {4}]",
+//			                     GetType().Name, CommentType, CommentText, StartPosition, EndPosition);
+//		}
+//		
+//		public override object AcceptVisitor(ISpecialVisitor visitor, object data)
+//		{
+//			return visitor.Visit(this, data);
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/CommentType.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/CommentType.cs
index c06844a34..1c9bb63e9 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/CommentType.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/CommentType.cs
@@ -5,10 +5,10 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB
 {
-	public enum CommentType
-	{
-		Block,
-		SingleLine,
-		Documentation
-	}
+//	public enum CommentType
+//	{
+//		Block,
+//		SingleLine,
+//		Documentation
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/ISpecial.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/ISpecial.cs
index ee6f106cd..a58964211 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/ISpecial.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/ISpecial.cs
@@ -5,48 +5,48 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB
 {
-	/// <summary>
-	/// Interface for all specials.
-	/// </summary>
-	public interface ISpecial
-	{
-		Location StartPosition { get; }
-		Location EndPosition { get; }
-		
-		object AcceptVisitor(ISpecialVisitor visitor, object data);
-	}
-	
-	public interface ISpecialVisitor
-	{
-		object Visit(ISpecial special, object data);
-		object Visit(BlankLine special, object data);
-		object Visit(Comment special, object data);
-		object Visit(PreprocessingDirective special, object data);
-	}
-	
-	public abstract class AbstractSpecial : ISpecial
-	{
-		public abstract object AcceptVisitor(ISpecialVisitor visitor, object data);
-		
-		protected AbstractSpecial(Location position)
-		{
-			this.StartPosition = position;
-			this.EndPosition = position;
-		}
-		
-		protected AbstractSpecial(Location startPosition, Location endPosition)
-		{
-			this.StartPosition = startPosition;
-			this.EndPosition = endPosition;
-		}
-		
-		public Location StartPosition { get; set; }
-		public Location EndPosition { get; set; }
-		
-		public override string ToString()
-		{
-			return String.Format("[{0}: Start = {1}, End = {2}]",
-			                     GetType().Name, StartPosition, EndPosition);
-		}
-	}
+//	/// <summary>
+//	/// Interface for all specials.
+//	/// </summary>
+//	public interface ISpecial
+//	{
+//		Location StartPosition { get; }
+//		Location EndPosition { get; }
+//		
+//		object AcceptVisitor(ISpecialVisitor visitor, object data);
+//	}
+//	
+//	public interface ISpecialVisitor
+//	{
+//		object Visit(ISpecial special, object data);
+//		object Visit(BlankLine special, object data);
+//		object Visit(Comment special, object data);
+//		object Visit(PreprocessingDirective special, object data);
+//	}
+//	
+//	public abstract class AbstractSpecial : ISpecial
+//	{
+//		public abstract object AcceptVisitor(ISpecialVisitor visitor, object data);
+//		
+//		protected AbstractSpecial(Location position)
+//		{
+//			this.StartPosition = position;
+//			this.EndPosition = position;
+//		}
+//		
+//		protected AbstractSpecial(Location startPosition, Location endPosition)
+//		{
+//			this.StartPosition = startPosition;
+//			this.EndPosition = endPosition;
+//		}
+//		
+//		public Location StartPosition { get; set; }
+//		public Location EndPosition { get; set; }
+//		
+//		public override string ToString()
+//		{
+//			return String.Format("[{0}: Start = {1}, End = {2}]",
+//			                     GetType().Name, StartPosition, EndPosition);
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/PreProcessingDirective.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/PreProcessingDirective.cs
index 9d244528c..97c0a7481 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/PreProcessingDirective.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/PreProcessingDirective.cs
@@ -6,151 +6,151 @@ using System.Collections.Generic;
 
 namespace ICSharpCode.NRefactory.VB
 {
-	public class PreprocessingDirective : AbstractSpecial
-	{
-		#region Conversion C# <-> VB
-		public static void VBToCSharp(IList<ISpecial> list)
-		{
-			for (int i = 0; i < list.Count; ++i) {
-				if (list[i] is PreprocessingDirective)
-					list[i] = VBToCSharp((PreprocessingDirective)list[i]);
-			}
-		}
-		
-		public static PreprocessingDirective VBToCSharp(PreprocessingDirective dir)
-		{
-			string cmd = dir.Cmd;
-			string arg = dir.Arg;
-			if (cmd.Equals("#End", StringComparison.InvariantCultureIgnoreCase)) {
-				if (arg.ToLowerInvariant().StartsWith("region")) {
-					cmd = "#endregion";
-					arg = "";
-				} else if ("if".Equals(arg, StringComparison.InvariantCultureIgnoreCase)) {
-					cmd = "#endif";
-					arg = "";
-				}
-			} else if (cmd.Equals("#Region", StringComparison.InvariantCultureIgnoreCase)) {
-				cmd = "#region";
-			} else if (cmd.Equals("#If", StringComparison.InvariantCultureIgnoreCase)) {
-				cmd = "#if";
-				if (arg.ToLowerInvariant().EndsWith(" then"))
-					arg = arg.Substring(0, arg.Length - 5);
-			} else if (cmd.Equals("#Else", StringComparison.InvariantCultureIgnoreCase)) {
-				if (dir.Expression != null)
-					cmd = "#elif";
-				else
-					cmd = "#else";
-			} else if (cmd.Equals("#ElseIf", StringComparison.InvariantCultureIgnoreCase)) {
-				cmd = "#elif";
-			}
-			return new PreprocessingDirective(cmd, arg, dir.StartPosition, dir.EndPosition) {
-				Expression = dir.Expression
-			};
-		}
-		
-		public static void CSharpToVB(List<ISpecial> list)
-		{
-			for (int i = 0; i < list.Count; ++i) {
-				if (list[i] is PreprocessingDirective)
-					list[i] = CSharpToVB((PreprocessingDirective)list[i]);
-			}
-		}
-		
-		public static PreprocessingDirective CSharpToVB(PreprocessingDirective dir)
-		{
-			string cmd = dir.Cmd;
-			string arg = dir.Arg;
-			switch (cmd) {
-				case "#region":
-					cmd = "#Region";
-					if (!arg.StartsWith("\"")) {
-						arg = "\"" + arg.Trim() + "\"";
-					}
-					break;
-				case "#endregion":
-					cmd = "#End";
-					arg = "Region";
-					break;
-				case "#endif":
-					cmd = "#End";
-					arg = "If";
-					break;
-				case "#if":
-					arg += " Then";
-					break;
-			}
-			if (cmd.Length > 1) {
-				cmd = cmd.Substring(0, 2).ToUpperInvariant() + cmd.Substring(2);
-			}
-			return new PreprocessingDirective(cmd, arg, dir.StartPosition, dir.EndPosition) {
-				Expression = dir.Expression
-			};
-		}
-		#endregion
-		
-		string cmd;
-		string arg;
-		Ast.Expression expression = Ast.Expression.Null;
-		
-		/// <summary>
-		/// Gets the directive name, including '#'.
-		/// </summary>
-		public string Cmd {
-			get {
-				return cmd;
-			}
-			set {
-				cmd = value ?? string.Empty;
-			}
-		}
-		
-		/// <summary>
-		/// Gets the directive argument.
-		/// </summary>
-		public string Arg {
-			get {
-				return arg;
-			}
-			set {
-				arg = value ?? string.Empty;
-			}
-		}
-		
-		/// <summary>
-		/// Gets/sets the expression (for directives that take an expression, e.g. #if and #elif).
-		/// </summary>
-		public Ast.Expression Expression {
-			get { return expression; }
-			set { expression = value ?? Ast.Expression.Null; }
-		}
-		
-		/// <value>
-		/// The end position of the pre processor directive line.
-		/// May be != EndPosition.
-		/// </value>
-		public Location LastLineEnd {
-			get;
-			set;
-		}
-		
-				
-		public override string ToString()
-		{
-			return String.Format("[PreProcessingDirective: Cmd = {0}, Arg = {1}]",
-			                     Cmd,
-			                     Arg);
-		}
-		
-		public PreprocessingDirective(string cmd, string arg, Location start, Location end)
-			: base(start, end)
-		{
-			this.Cmd = cmd;
-			this.Arg = arg;
-		}
-		
-		public override object AcceptVisitor(ISpecialVisitor visitor, object data)
-		{
-			return visitor.Visit(this, data);
-		}
-	}
+//	public class PreprocessingDirective : AbstractSpecial
+//	{
+//		#region Conversion C# <-> VB
+//		public static void VBToCSharp(IList<ISpecial> list)
+//		{
+//			for (int i = 0; i < list.Count; ++i) {
+//				if (list[i] is PreprocessingDirective)
+//					list[i] = VBToCSharp((PreprocessingDirective)list[i]);
+//			}
+//		}
+//		
+//		public static PreprocessingDirective VBToCSharp(PreprocessingDirective dir)
+//		{
+//			string cmd = dir.Cmd;
+//			string arg = dir.Arg;
+//			if (cmd.Equals("#End", StringComparison.InvariantCultureIgnoreCase)) {
+//				if (arg.ToLowerInvariant().StartsWith("region")) {
+//					cmd = "#endregion";
+//					arg = "";
+//				} else if ("if".Equals(arg, StringComparison.InvariantCultureIgnoreCase)) {
+//					cmd = "#endif";
+//					arg = "";
+//				}
+//			} else if (cmd.Equals("#Region", StringComparison.InvariantCultureIgnoreCase)) {
+//				cmd = "#region";
+//			} else if (cmd.Equals("#If", StringComparison.InvariantCultureIgnoreCase)) {
+//				cmd = "#if";
+//				if (arg.ToLowerInvariant().EndsWith(" then"))
+//					arg = arg.Substring(0, arg.Length - 5);
+//			} else if (cmd.Equals("#Else", StringComparison.InvariantCultureIgnoreCase)) {
+//				if (dir.Expression != null)
+//					cmd = "#elif";
+//				else
+//					cmd = "#else";
+//			} else if (cmd.Equals("#ElseIf", StringComparison.InvariantCultureIgnoreCase)) {
+//				cmd = "#elif";
+//			}
+//			return new PreprocessingDirective(cmd, arg, dir.StartPosition, dir.EndPosition) {
+//				Expression = dir.Expression
+//			};
+//		}
+//		
+//		public static void CSharpToVB(List<ISpecial> list)
+//		{
+//			for (int i = 0; i < list.Count; ++i) {
+//				if (list[i] is PreprocessingDirective)
+//					list[i] = CSharpToVB((PreprocessingDirective)list[i]);
+//			}
+//		}
+//		
+//		public static PreprocessingDirective CSharpToVB(PreprocessingDirective dir)
+//		{
+//			string cmd = dir.Cmd;
+//			string arg = dir.Arg;
+//			switch (cmd) {
+//				case "#region":
+//					cmd = "#Region";
+//					if (!arg.StartsWith("\"")) {
+//						arg = "\"" + arg.Trim() + "\"";
+//					}
+//					break;
+//				case "#endregion":
+//					cmd = "#End";
+//					arg = "Region";
+//					break;
+//				case "#endif":
+//					cmd = "#End";
+//					arg = "If";
+//					break;
+//				case "#if":
+//					arg += " Then";
+//					break;
+//			}
+//			if (cmd.Length > 1) {
+//				cmd = cmd.Substring(0, 2).ToUpperInvariant() + cmd.Substring(2);
+//			}
+//			return new PreprocessingDirective(cmd, arg, dir.StartPosition, dir.EndPosition) {
+//				Expression = dir.Expression
+//			};
+//		}
+//		#endregion
+//		
+//		string cmd;
+//		string arg;
+//		Ast.Expression expression = Ast.Expression.Null;
+//		
+//		/// <summary>
+//		/// Gets the directive name, including '#'.
+//		/// </summary>
+//		public string Cmd {
+//			get {
+//				return cmd;
+//			}
+//			set {
+//				cmd = value ?? string.Empty;
+//			}
+//		}
+//		
+//		/// <summary>
+//		/// Gets the directive argument.
+//		/// </summary>
+//		public string Arg {
+//			get {
+//				return arg;
+//			}
+//			set {
+//				arg = value ?? string.Empty;
+//			}
+//		}
+//		
+//		/// <summary>
+//		/// Gets/sets the expression (for directives that take an expression, e.g. #if and #elif).
+//		/// </summary>
+//		public Ast.Expression Expression {
+//			get { return expression; }
+//			set { expression = value ?? Ast.Expression.Null; }
+//		}
+//		
+//		/// <value>
+//		/// The end position of the pre processor directive line.
+//		/// May be != EndPosition.
+//		/// </value>
+//		public Location LastLineEnd {
+//			get;
+//			set;
+//		}
+//		
+//				
+//		public override string ToString()
+//		{
+//			return String.Format("[PreProcessingDirective: Cmd = {0}, Arg = {1}]",
+//			                     Cmd,
+//			                     Arg);
+//		}
+//		
+//		public PreprocessingDirective(string cmd, string arg, Location start, Location end)
+//			: base(start, end)
+//		{
+//			this.Cmd = cmd;
+//			this.Arg = arg;
+//		}
+//		
+//		public override object AcceptVisitor(ISpecialVisitor visitor, object data)
+//		{
+//			return visitor.Visit(this, data);
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/SpecialTracker.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/SpecialTracker.cs
index b59f8c095..2107163e4 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/SpecialTracker.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/SpecialTracker.cs
@@ -7,65 +7,65 @@ using System.Text;
 
 namespace ICSharpCode.NRefactory.VB.Parser
 {
-	public class SpecialTracker
-	{
-		List<ISpecial> currentSpecials = new List<ISpecial>();
-		
-		CommentType   currentCommentType;
-		StringBuilder sb = new StringBuilder();
-		Location         startPosition;
-		bool commentStartsLine;
-		
-		public List<ISpecial> CurrentSpecials {
-			get {
-				return currentSpecials;
-			}
-		}
-		
-		/// <summary>
-		/// Gets the specials from the SpecialTracker and resets the lists.
-		/// </summary>
-		public List<ISpecial> RetrieveSpecials()
-		{
-			List<ISpecial> tmp = currentSpecials;
-			currentSpecials = new List<ISpecial>();
-			return tmp;
-		}
-		
-		public void AddEndOfLine(Location point)
-		{
-			currentSpecials.Add(new BlankLine(point));
-		}
-		
-		public void AddPreprocessingDirective(PreprocessingDirective directive)
-		{
-			if (directive == null)
-				throw new ArgumentNullException("directive");
-			currentSpecials.Add(directive);
-		}
-		
-		// used for comment tracking
-		public void StartComment(CommentType commentType, bool commentStartsLine, Location startPosition)
-		{
-			this.currentCommentType = commentType;
-			this.startPosition      = startPosition;
-			this.sb.Length          = 0;
-			this.commentStartsLine  = commentStartsLine;
-		}
-		
-		public void AddChar(char c)
-		{
-			sb.Append(c);
-		}
-		
-		public void AddString(string s)
-		{
-			sb.Append(s);
-		}
-		
-		public void FinishComment(Location endPosition)
-		{
-			currentSpecials.Add(new Comment(currentCommentType, sb.ToString(), commentStartsLine, startPosition, endPosition));
-		}
-	}
+//	public class SpecialTracker
+//	{
+//		List<ISpecial> currentSpecials = new List<ISpecial>();
+//		
+//		CommentType   currentCommentType;
+//		StringBuilder sb = new StringBuilder();
+//		Location         startPosition;
+//		bool commentStartsLine;
+//		
+//		public List<ISpecial> CurrentSpecials {
+//			get {
+//				return currentSpecials;
+//			}
+//		}
+//		
+//		/// <summary>
+//		/// Gets the specials from the SpecialTracker and resets the lists.
+//		/// </summary>
+//		public List<ISpecial> RetrieveSpecials()
+//		{
+//			List<ISpecial> tmp = currentSpecials;
+//			currentSpecials = new List<ISpecial>();
+//			return tmp;
+//		}
+//		
+//		public void AddEndOfLine(Location point)
+//		{
+//			currentSpecials.Add(new BlankLine(point));
+//		}
+//		
+//		public void AddPreprocessingDirective(PreprocessingDirective directive)
+//		{
+//			if (directive == null)
+//				throw new ArgumentNullException("directive");
+//			currentSpecials.Add(directive);
+//		}
+//		
+//		// used for comment tracking
+//		public void StartComment(CommentType commentType, bool commentStartsLine, Location startPosition)
+//		{
+//			this.currentCommentType = commentType;
+//			this.startPosition      = startPosition;
+//			this.sb.Length          = 0;
+//			this.commentStartsLine  = commentStartsLine;
+//		}
+//		
+//		public void AddChar(char c)
+//		{
+//			sb.Append(c);
+//		}
+//		
+//		public void AddString(string s)
+//		{
+//			sb.Append(s);
+//		}
+//		
+//		public void FinishComment(Location endPosition)
+//		{
+//			currentSpecials.Add(new Comment(currentCommentType, sb.ToString(), commentStartsLine, startPosition, endPosition));
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/TagComment.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/TagComment.cs
index 7023c1c66..3209cf162 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/TagComment.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Special/TagComment.cs
@@ -8,22 +8,22 @@ namespace ICSharpCode.NRefactory.VB.Parser
 	/// <summary>
 	/// Description of TagComment.	
 	/// </summary>
-	public class TagComment : Comment
-	{
-		string tag;
-		
-		public string Tag {
-			get {
-				return tag;
-			}
-			set {
-				tag = value;
-			}
-		}
-		
-		public TagComment(string tag, string comment, bool commentStartsLine, Location startPosition, Location endPosition) : base(CommentType.SingleLine, comment, commentStartsLine, startPosition, endPosition)
-		{
-			this.tag = tag;
-		}
-	}
+//	public class TagComment : Comment
+//	{
+//		string tag;
+//		
+//		public string Tag {
+//			get {
+//				return tag;
+//			}
+//			set {
+//				tag = value;
+//			}
+//		}
+//		
+//		public TagComment(string tag, string comment, bool commentStartsLine, Location startPosition, Location endPosition) : base(CommentType.SingleLine, comment, commentStartsLine, startPosition, endPosition)
+//		{
+//			this.tag = tag;
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Token.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Token.cs
index a67002b32..ae4ed7d63 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Token.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/Token.cs
@@ -5,18 +5,6 @@ using System;
 
 namespace ICSharpCode.NRefactory.VB.Parser
 {
-	public enum LiteralFormat : byte
-	{
-		None,
-		DecimalNumber,
-		HexadecimalNumber,
-		OctalNumber,
-		StringLiteral,
-		VerbatimStringLiteral,
-		CharLiteral,
-		DateTimeLiteral
-	}
-	
 	public class Token
 	{
 		internal readonly int kind;
@@ -24,20 +12,15 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		internal readonly int col;
 		internal readonly int line;
 		
-		internal readonly LiteralFormat literalFormat;
 		internal readonly object literalValue;
 		internal readonly string val;
 		internal Token next;
-		readonly Location endLocation;
+		readonly AstLocation endLocation;
 		
 		public int Kind {
 			get { return kind; }
 		}
 		
-		public LiteralFormat LiteralFormat {
-			get { return literalFormat; }
-		}
-		
 		public object LiteralValue {
 			get { return literalValue; }
 		}
@@ -46,13 +29,13 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			get { return val; }
 		}
 		
-		public Location EndLocation {
+		public AstLocation EndLocation {
 			get { return endLocation; }
 		}
 		
-		public Location Location {
+		public AstLocation Location {
 			get {
-				return new Location(col, line);
+				return new AstLocation(line, col);
 			}
 		}
 		
@@ -65,7 +48,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		{
 		}
 		
-		public Token(int kind, Location startLocation, Location endLocation) : this(kind, startLocation, endLocation, "", null, LiteralFormat.None)
+		public Token(int kind, AstLocation startLocation, AstLocation endLocation) : this(kind, startLocation, endLocation, "", null)
 		{
 		}
 		
@@ -75,15 +58,15 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			this.col          = col;
 			this.line         = line;
 			this.val          = val;
-			this.endLocation  = new Location(col + (val == null ? 1 : val.Length), line);
+			this.endLocation  = new AstLocation(line, col + (val == null ? 1 : val.Length));
 		}
 		
-		internal Token(int kind, int x, int y, string val, object literalValue, LiteralFormat literalFormat)
-			: this(kind, new Location(x, y), new Location(x + val.Length, y), val, literalValue, literalFormat)
+		internal Token(int kind, int x, int y, string val, object literalValue)
+			: this(kind, new AstLocation(y, x), new AstLocation(y, x + val.Length), val, literalValue)
 		{
 		}
 		
-		public Token(int kind, Location startLocation, Location endLocation, string val, object literalValue, LiteralFormat literalFormat)
+		public Token(int kind, AstLocation startLocation, AstLocation endLocation, string val, object literalValue)
 		{
 			this.kind         = kind;
 			this.col          = startLocation.Column;
@@ -91,7 +74,6 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			this.endLocation = endLocation;
 			this.val          = val;
 			this.literalValue = literalValue;
-			this.literalFormat = literalFormat;
 		}
 		
 		public override string ToString()
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs
index 3944ba7cd..6aac502c2 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Lexer/VBLexer.cs
@@ -34,7 +34,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		
 		public VBLexer(TextReader reader, VBLexerMemento state) : this(reader)
 		{
-			SetInitialLocation(new Location(state.Column, state.Line));
+			SetInitialLocation(new AstLocation(state.Line, state.Column));
 			lastToken = new Token(state.PrevTokenKind, 0, 0);
 			ef = new ExpressionFinder(state.ExpressionFinder);
 			lineEnd = state.LineEnd;
@@ -54,7 +54,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			
 			unchecked {
 				while (true) {
-					Location startLocation = new Location(Col, Line);
+					AstLocation startLocation = new AstLocation(Line, Col);
 					int nextChar = ReaderRead();
 					if (nextChar == -1)
 						return new Token(Tokens.EOF, Col, Line, string.Empty);
@@ -96,12 +96,12 @@ namespace ICSharpCode.NRefactory.VB.Parser
 								if (ReaderPeek() == '/') {
 									ReaderRead();
 									info.inXmlCloseTag = true;
-									return new Token(Tokens.XmlOpenEndTag, new Location(x, y), new Location(Col, Line));
+									return new Token(Tokens.XmlOpenEndTag, new AstLocation(y, x), new AstLocation(Line, Col));
 								}
 								if (ReaderPeek() == '%' && ReaderPeek(1) == '=') {
 									inXmlMode = false;
 									ReaderRead(); ReaderRead();
-									return new Token(Tokens.XmlStartInlineVB, new Location(x, y), new Location(Col, Line));
+									return new Token(Tokens.XmlStartInlineVB, new AstLocation(y, x), new AstLocation(Line, Col));
 								}
 								if (ReaderPeek() == '?') {
 									ReaderRead();
@@ -122,7 +122,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 									ReaderRead();
 									info.inXmlTag = false;
 									info.level--;
-									return new Token(Tokens.XmlCloseTagEmptyElement, new Location(x, y), new Location(Col, Line));
+									return new Token(Tokens.XmlCloseTagEmptyElement, new AstLocation(y, x), new AstLocation(Line, Col));
 								}
 								break;
 							case '>':
@@ -135,7 +135,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 							case '\'':
 							case '"':
 								string s = ReadXmlString(ch);
-								return new Token(Tokens.LiteralString, x, y, ch + s + ch, s, LiteralFormat.StringLiteral);
+								return new Token(Tokens.LiteralString, x, y, ch + s + ch, s);
 							default:
 								if (info.inXmlCloseTag || info.inXmlTag) {
 									if (XmlConvert.IsWhitespaceChar(ch))
@@ -143,7 +143,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 									return new Token(Tokens.Identifier, x, y, ReadXmlIdent(ch));
 								} else {
 									string content = ReadXmlContent(ch);
-									return new Token(Tokens.XmlContent, startLocation, new Location(Col, Line), content, null, LiteralFormat.None);
+									return new Token(Tokens.XmlContent, startLocation, new AstLocation(Line, Col), content, null);
 								}
 						}
 						#endregion
@@ -154,10 +154,10 @@ namespace ICSharpCode.NRefactory.VB.Parser
 								if (lineEnd) {
 									// second line end before getting to a token
 									// -> here was a blank line
-									specialTracker.AddEndOfLine(startLocation);
+//									specialTracker.AddEndOfLine(startLocation);
 								} else {
 									lineEnd = true;
-									return new Token(Tokens.EOL, startLocation, new Location(Col, Line), null, null, LiteralFormat.None);
+									return new Token(Tokens.EOL, startLocation, new AstLocation(Line, Col), null, null);
 								}
 							}
 							continue;
@@ -212,7 +212,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 								} catch (Exception e) {
 									errors.Error(Line, Col, String.Format("Invalid date time {0}", e));
 								}
-								return new Token(Tokens.LiteralDate, x, y, s, time, LiteralFormat.DateTimeLiteral);
+								return new Token(Tokens.LiteralDate, x, y, s, time);
 							} else {
 								ReadPreprocessorDirective();
 								continue;
@@ -305,16 +305,16 @@ namespace ICSharpCode.NRefactory.VB.Parser
 								if (s.Length == 0) {
 									s = "\0";
 								}
-								return new Token(Tokens.LiteralCharacter, x, y, '"' + s  + "\"C", s[0], LiteralFormat.CharLiteral);
+								return new Token(Tokens.LiteralCharacter, x, y, '"' + s  + "\"C", s[0]);
 							}
-							return new Token(Tokens.LiteralString, x, y, '"' + s + '"', s, LiteralFormat.StringLiteral);
+							return new Token(Tokens.LiteralString, x, y, '"' + s + '"', s);
 						}
 						if (ch == '%' && ReaderPeek() == '>') {
 							int x = Col - 1;
 							int y = Line;
 							inXmlMode = true;
 							ReaderRead();
-							return new Token(Tokens.XmlEndInlineVB, new Location(x, y), new Location(Col, Line));
+							return new Token(Tokens.XmlEndInlineVB, new AstLocation(y, x), new AstLocation(Line, Col));
 						}
 						#endregion
 						if (ch == '<' && (ef.NextTokenIsPotentialStartOfExpression || ef.NextTokenIsStartOfImportsOrAccessExpression)) {
@@ -326,13 +326,13 @@ namespace ICSharpCode.NRefactory.VB.Parser
 							if (ReaderPeek() == '/') {
 								ReaderRead();
 								info.inXmlCloseTag = true;
-								return new Token(Tokens.XmlOpenEndTag, new Location(x, y), new Location(Col, Line));
+								return new Token(Tokens.XmlOpenEndTag, new AstLocation(y, x), new AstLocation(Line, Col));
 							}
 							// should we allow <%= at start of an expression? not valid with vbc ...
 							if (ReaderPeek() == '%' && ReaderPeek(1) == '=') {
 								inXmlMode = false;
 								ReaderRead(); ReaderRead();
-								return new Token(Tokens.XmlStartInlineVB, new Location(x, y), new Location(Col, Line));
+								return new Token(Tokens.XmlStartInlineVB, new AstLocation(y, x), new AstLocation(Line, Col));
 							}
 							if (ReaderPeek() == '!') {
 								ReaderRead();
@@ -361,7 +361,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			}
 		}
 
-		void CheckXMLState(Location startLocation)
+		void CheckXMLState(AstLocation startLocation)
 		{
 			if (inXmlMode && !xmlModeStack.Any())
 				throw new InvalidOperationException("invalid XML stack state at " + startLocation);
@@ -563,7 +563,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 				if (ch == '&') {
 					errors.Error(Line, Col, String.Format("digit expected"));
 				}
-				return new Token(Tokens.LiteralInteger, x, y, sb.ToString() ,ch - '0', LiteralFormat.DecimalNumber);
+				return new Token(Tokens.LiteralInteger, x, y, sb.ToString() ,ch - '0');
 			}
 			if (ch == '.') {
 				if (Char.IsDigit((char)ReaderPeek())) {
@@ -603,7 +603,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			
 			if (digit.Length == 0) {
 				errors.Error(Line, Col, String.Format("digit expected"));
-				return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.DecimalNumber);
+				return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0);
 			}
 			
 			if (ReaderPeek() != -1 && "%&SILU".IndexOf(PeekUpperChar()) != -1 || isHex || isOct) {
@@ -632,60 +632,59 @@ namespace ICSharpCode.NRefactory.VB.Parser
 						}
 						if (ch == 'S') {
 							if (unsigned)
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (ushort)number, LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (ushort)number);
 							else
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (short)number, LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (short)number);
 						} else if (ch == '%' || ch == 'I') {
 							if (unsigned)
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (uint)number, LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (uint)number);
 							else
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (int)number, LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (int)number);
 						} else if (ch == '&' || ch == 'L') {
 							if (unsigned)
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (ulong)number, LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (ulong)number);
 							else
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (long)number, LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), (long)number);
 						} else {
 							if (number > uint.MaxValue) {
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((long)number), LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((long)number));
 							} else {
-								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((int)number), LiteralFormat.OctalNumber);
+								return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((int)number));
 							}
 						}
 					}
-					LiteralFormat literalFormat = isHex ? LiteralFormat.HexadecimalNumber : LiteralFormat.DecimalNumber;
 					if (ch == 'S') {
 						ReaderRead();
 						if (unsigned)
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt16.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt16.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 						else
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int16.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int16.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 					} else if (ch == '%' || ch == 'I') {
 						ReaderRead();
 						if (unsigned)
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt32.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt32.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 						else
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 					} else if (ch == '&' || ch == 'L') {
 						ReaderRead();
 						if (unsigned)
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt64.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), UInt64.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 						else
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 					} else if (isHex) {
 						ulong number = UInt64.Parse(digit, NumberStyles.HexNumber);
 						if (number > uint.MaxValue) {
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((long)number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((long)number));
 						} else {
-							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((int)number), literalFormat);
+							return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), unchecked((int)number));
 						}
 					}
 				} catch (OverflowException ex) {
 					errors.Error(Line, Col, ex.Message);
-					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.None);
+					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0);
 				} catch (FormatException) {
 					errors.Error(Line, Col, String.Format("{0} is not a parseable number", digit));
-					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.None);
+					return new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0);
 				}
 			}
 			Token nextToken = null; // if we accidently read a 'dot'
@@ -738,37 +737,37 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			
 			try {
 				if (isSingle) {
-					return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), Single.Parse(digit, CultureInfo.InvariantCulture), LiteralFormat.DecimalNumber);
+					return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), Single.Parse(digit, CultureInfo.InvariantCulture));
 				}
 				if (isDecimal) {
-					return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), Decimal.Parse(digit, NumberStyles.Currency | NumberStyles.AllowExponent, CultureInfo.InvariantCulture), LiteralFormat.DecimalNumber);
+					return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), Decimal.Parse(digit, NumberStyles.Currency | NumberStyles.AllowExponent, CultureInfo.InvariantCulture));
 				}
 				if (isDouble) {
-					return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), Double.Parse(digit, CultureInfo.InvariantCulture), LiteralFormat.DecimalNumber);
+					return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), Double.Parse(digit, CultureInfo.InvariantCulture));
 				}
 			} catch (FormatException) {
 				errors.Error(Line, Col, String.Format("{0} is not a parseable number", digit));
 				if (isSingle)
-					return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), 0f, LiteralFormat.DecimalNumber);
+					return new Token(Tokens.LiteralSingle, x, y, sb.ToString(), 0f);
 				if (isDecimal)
-					return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), 0m, LiteralFormat.DecimalNumber);
+					return new Token(Tokens.LiteralDecimal, x, y, sb.ToString(), 0m);
 				if (isDouble)
-					return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), 0.0, LiteralFormat.DecimalNumber);
+					return new Token(Tokens.LiteralDouble, x, y, sb.ToString(), 0.0);
 			}
 			Token token;
 			try {
-				token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), isHex ? LiteralFormat.HexadecimalNumber : LiteralFormat.DecimalNumber);
+				token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int32.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 			} catch (Exception) {
 				try {
-					token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number), isHex ? LiteralFormat.HexadecimalNumber : LiteralFormat.DecimalNumber);
+					token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), Int64.Parse(digit, isHex ? NumberStyles.HexNumber : NumberStyles.Number));
 				} catch (FormatException) {
 					errors.Error(Line, Col, String.Format("{0} is not a parseable number", digit));
 					// fallback, when nothing helps :)
-					token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.DecimalNumber);
+					token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0);
 				} catch (OverflowException) {
 					errors.Error(Line, Col, String.Format("{0} is too long for a integer literal", digit));
 					// fallback, when nothing helps :)
-					token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0, LiteralFormat.DecimalNumber);
+					token = new Token(Tokens.LiteralInteger, x, y, sb.ToString(), 0);
 				}
 			}
 			token.next = nextToken;
@@ -777,12 +776,12 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		
 		void ReadPreprocessorDirective()
 		{
-			Location start = new Location(Col - 1, Line);
+			AstLocation start = new AstLocation(Line, Col - 1);
 			string directive = ReadIdent('#');
 			// TODO : expression parser for PP directives
 			// needed for proper conversion to e. g. C#
 			string argument  = ReadToEndOfLine();
-			this.specialTracker.AddPreprocessingDirective(new PreprocessingDirective(directive, argument.Trim(), start, new Location(start.Column + directive.Length + argument.Length, start.Line)));
+//			this.specialTracker.AddPreprocessingDirective(new PreprocessingDirective(directive, argument.Trim(), start, new AstLocation(start.Line, start.Column + directive.Length + argument.Length)));
 		}
 		
 		string ReadDate()
@@ -834,7 +833,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		
 		void ReadComment()
 		{
-			Location startPos = new Location(Col, Line);
+			AstLocation startPos = new AstLocation(Line, Col);
 			sb.Length = 0;
 			StringBuilder curWord = specialCommentHash != null ? new StringBuilder() : null;
 			int missingApostrophes = 2; // no. of ' missing until it is a documentation comment
@@ -851,11 +850,11 @@ namespace ICSharpCode.NRefactory.VB.Parser
 				if (missingApostrophes > 0) {
 					if (ch == '\'' || ch == '\u2018' || ch == '\u2019') {
 						if (--missingApostrophes == 0) {
-							specialTracker.StartComment(CommentType.Documentation, isAtLineBegin, startPos);
+//							specialTracker.StartComment(CommentType.Documentation, isAtLineBegin, startPos);
 							sb.Length = 0;
 						}
 					} else {
-						specialTracker.StartComment(CommentType.SingleLine, isAtLineBegin, startPos);
+//						specialTracker.StartComment(CommentType.SingleLine, isAtLineBegin, startPos);
 						missingApostrophes = 0;
 					}
 				}
@@ -867,20 +866,20 @@ namespace ICSharpCode.NRefactory.VB.Parser
 						string tag = curWord.ToString();
 						curWord.Length = 0;
 						if (specialCommentHash.ContainsKey(tag)) {
-							Location p = new Location(Col, Line);
+							AstLocation p = new AstLocation(Line, Col);
 							string comment = ch + ReadToEndOfLine();
-							this.TagComments.Add(new TagComment(tag, comment, isAtLineBegin, p, new Location(Col, Line)));
+//							this.TagComments.Add(new TagComment(tag, comment, isAtLineBegin, p, new Location(Col, Line)));
 							sb.Append(comment);
 							break;
 						}
 					}
 				}
 			}
-			if (missingApostrophes > 0) {
-				specialTracker.StartComment(CommentType.SingleLine, isAtLineBegin, startPos);
-			}
-			specialTracker.AddString(sb.ToString());
-			specialTracker.FinishComment(new Location(Col, Line));
+//			if (missingApostrophes > 0) {
+//				specialTracker.StartComment(CommentType.SingleLine, isAtLineBegin, startPos);
+//			}
+//			specialTracker.AddString(sb.ToString());
+//			specialTracker.FinishComment(new Location(Col, Line));
 		}
 		
 		Token ReadOperator(char ch)
@@ -1047,7 +1046,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			
 			ReaderSkip("?>".Length);
 			
-			return new Token(Tokens.XmlProcessingInstruction, new Location(x, y), new Location(Col, Line), sb.ToString(), null, LiteralFormat.None);
+			return new Token(Tokens.XmlProcessingInstruction, new AstLocation(y, x), new AstLocation(Line, Col), sb.ToString(), null);
 		}
 		
 		Token ReadXmlCommentOrCData(int x, int y)
@@ -1061,7 +1060,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 					sb.Append((char)nextChar);
 					if (string.CompareOrdinal(ReaderPeekString("-->".Length), "-->") == 0) {
 						ReaderSkip("-->".Length);
-						return new Token(Tokens.XmlComment, new Location(x, y), new Location(Col, Line), sb.ToString(), null, LiteralFormat.None);
+						return new Token(Tokens.XmlComment, new AstLocation(y, x), new AstLocation(Line, Col), sb.ToString(), null);
 					}
 				}
 			}
@@ -1072,12 +1071,12 @@ namespace ICSharpCode.NRefactory.VB.Parser
 					sb.Append((char)nextChar);
 					if (string.CompareOrdinal(ReaderPeekString("]]>".Length), "]]>") == 0) {
 						ReaderSkip("]]>".Length);
-						return new Token(Tokens.XmlCData, new Location(x, y), new Location(Col, Line), sb.ToString(), null, LiteralFormat.None);
+						return new Token(Tokens.XmlCData, new AstLocation(y, x), new AstLocation(Line, Col), sb.ToString(), null);
 					}
 				}
 			}
 			
-			return new Token(Tokens.XmlComment, new Location(x, y), new Location(Col, Line), sb.ToString(), null, LiteralFormat.None);
+			return new Token(Tokens.XmlComment, new AstLocation(y, x), new AstLocation(Line, Col), sb.ToString(), null);
 		}
 		
 		string ReadXmlContent(char ch)
@@ -1188,9 +1187,9 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		
 		string[]  specialCommentTags = null;
 		protected Hashtable specialCommentHash  = null;
-		List<TagComment> tagComments  = new List<TagComment>();
+//		List<TagComment> tagComments  = new List<TagComment>();
 		protected StringBuilder sb              = new StringBuilder();
-		protected SpecialTracker specialTracker = new SpecialTracker();
+//		protected SpecialTracker specialTracker = new SpecialTracker();
 		
 		// used for the original value of strings (with escape sequences).
 		protected StringBuilder originalValue = new StringBuilder();
@@ -1277,7 +1276,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			return builder.ToString();
 		}
 		
-		public void SetInitialLocation(Location location)
+		public void SetInitialLocation(AstLocation location)
 		{
 			if (lastToken != null || curToken != null || peekToken != null)
 				throw new InvalidOperationException();
@@ -1294,17 +1293,17 @@ namespace ICSharpCode.NRefactory.VB.Parser
 		/// <summary>
 		/// Returns the comments that had been read and containing tag key words.
 		/// </summary>
-		public List<TagComment> TagComments {
-			get {
-				return tagComments;
-			}
-		}
+//		public List<TagComment> TagComments {
+//			get {
+//				return tagComments;
+//			}
+//		}
 		
-		public SpecialTracker SpecialTracker {
-			get {
-				return specialTracker;
-			}
-		}
+//		public SpecialTracker SpecialTracker {
+//			get {
+//				return specialTracker;
+//			}
+//		}
 		
 		/// <summary>
 		/// Special comment tags are tags like TODO, HACK or UNDONE which are read by the lexer and stored in <see cref="TagComments"/>.
@@ -1353,7 +1352,6 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			errors = null;
 			lastToken = curToken = peekToken = null;
 			specialCommentHash = null;
-			tagComments = null;
 			sb = originalValue = null;
 		}
 		#endregion
@@ -1406,12 +1404,12 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			errors.Error(line, col, String.Format("Invalid hex number '" + digit + "'"));
 			return 0;
 		}
-		protected Location lastLineEnd = new Location (1, 1);
-		protected Location curLineEnd = new Location (1, 1);
+		protected AstLocation lastLineEnd = new AstLocation(1, 1);
+		protected AstLocation curLineEnd = new AstLocation(1, 1);
 		protected void LineBreak ()
 		{
 			lastLineEnd = curLineEnd;
-			curLineEnd = new Location (col - 1, line);
+			curLineEnd = new AstLocation (line, col - 1);
 		}
 		protected bool HandleLineEnd(char ch)
 		{
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Location.cs b/NRefactory/ICSharpCode.NRefactory.VB/Location.cs
deleted file mode 100644
index 825207f05..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Location.cs
+++ /dev/null
@@ -1,121 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-
-namespace ICSharpCode.NRefactory.VB
-{
-	/// <summary>
-	/// A line/column position.
-	/// NRefactory lines/columns are counting from one.
-	/// </summary>
-	public struct Location : IComparable<Location>, IEquatable<Location>
-	{
-		public static readonly Location Empty = new Location(-1, -1);
-		
-		public Location(int column, int line)
-		{
-			x = column;
-			y = line;
-		}
-		
-		int x, y;
-		
-		public int X {
-			get { return x; }
-			set { x = value; }
-		}
-		
-		public int Y {
-			get { return y; }
-			set { y = value; }
-		}
-		
-		public int Line {
-			get { return y; }
-			set { y = value; }
-		}
-		
-		public int Column {
-			get { return x; }
-			set { x = value; }
-		}
-		
-		public bool IsEmpty {
-			get {
-				return x <= 0 && y <= 0;
-			}
-		}
-		
-		public override string ToString()
-		{
-			return string.Format("(Line {1}, Col {0})", this.x, this.y);
-		}
-		
-		public override int GetHashCode()
-		{
-			return unchecked (87 * x.GetHashCode() ^ y.GetHashCode());
-		}
-		
-		public override bool Equals(object obj)
-		{
-			if (!(obj is Location)) return false;
-			return (Location)obj == this;
-		}
-		
-		public bool Equals(Location other)
-		{
-			return this == other;
-		}
-		
-		public static bool operator ==(Location a, Location b)
-		{
-			return a.x == b.x && a.y == b.y;
-		}
-		
-		public static bool operator !=(Location a, Location b)
-		{
-			return a.x != b.x || a.y != b.y;
-		}
-		
-		public static bool operator <(Location a, Location b)
-		{
-			if (a.y < b.y)
-				return true;
-			else if (a.y == b.y)
-				return a.x < b.x;
-			else
-				return false;
-		}
-		
-		public static bool operator >(Location a, Location b)
-		{
-			if (a.y > b.y)
-				return true;
-			else if (a.y == b.y)
-				return a.x > b.x;
-			else
-				return false;
-		}
-		
-		public static bool operator <=(Location a, Location b)
-		{
-			return !(a > b);
-		}
-		
-		public static bool operator >=(Location a, Location b)
-		{
-			return !(a < b);
-		}
-		
-		public int CompareTo(Location other)
-		{
-			if (this == other)
-				return 0;
-			if (this < other)
-				return -1;
-			else
-				return 1;
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/OperatorPrecedence.cs b/NRefactory/ICSharpCode.NRefactory.VB/OperatorPrecedence.cs
deleted file mode 100644
index 833802ffd..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/OperatorPrecedence.cs
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB
-{
-	/// <summary>
-	/// Stores the operator precedences for the output visitor.
-	/// </summary>
-	static class OperatorPrecedence
-	{
-		static readonly Dictionary<BinaryOperatorType, int> vbDict = MakePrecedenceTable(
-			new BinaryOperatorType[] { BinaryOperatorType.Power },
-			new BinaryOperatorType[] { BinaryOperatorType.Multiply, BinaryOperatorType.Divide },
-			new BinaryOperatorType[] { BinaryOperatorType.DivideInteger },
-			new BinaryOperatorType[] { BinaryOperatorType.Modulus },
-			new BinaryOperatorType[] { BinaryOperatorType.Add, BinaryOperatorType.Subtract },
-			new BinaryOperatorType[] { BinaryOperatorType.Concat },
-			new BinaryOperatorType[] { BinaryOperatorType.ShiftLeft, BinaryOperatorType.ShiftRight },
-			new BinaryOperatorType[] {
-				BinaryOperatorType.Equality, BinaryOperatorType.InEquality,
-				BinaryOperatorType.LessThan, BinaryOperatorType.LessThanOrEqual,
-				BinaryOperatorType.GreaterThan, BinaryOperatorType.GreaterThanOrEqual,
-				BinaryOperatorType.ReferenceEquality, BinaryOperatorType.ReferenceInequality,
-				BinaryOperatorType.Like
-			},
-			new BinaryOperatorType[] { BinaryOperatorType.LogicalAnd, BinaryOperatorType.BitwiseAnd },
-			new BinaryOperatorType[] { BinaryOperatorType.LogicalOr, BinaryOperatorType.BitwiseOr },
-			new BinaryOperatorType[] { BinaryOperatorType.ExclusiveOr }
-		);
-		
-		static readonly Dictionary<BinaryOperatorType, int> csharpDict = MakePrecedenceTable(
-			new BinaryOperatorType[] { BinaryOperatorType.Multiply, BinaryOperatorType.Divide, BinaryOperatorType.Modulus },
-			new BinaryOperatorType[] { BinaryOperatorType.Add, BinaryOperatorType.Subtract },
-			new BinaryOperatorType[] { BinaryOperatorType.ShiftLeft, BinaryOperatorType.ShiftRight },
-			new BinaryOperatorType[] {
-				BinaryOperatorType.LessThan, BinaryOperatorType.LessThanOrEqual,
-				BinaryOperatorType.GreaterThan, BinaryOperatorType.GreaterThanOrEqual,
-			},
-			new BinaryOperatorType[] { BinaryOperatorType.Equality, BinaryOperatorType.InEquality },
-			new BinaryOperatorType[] { BinaryOperatorType.BitwiseAnd },
-			new BinaryOperatorType[] { BinaryOperatorType.ExclusiveOr },
-			new BinaryOperatorType[] { BinaryOperatorType.BitwiseOr },
-			new BinaryOperatorType[] { BinaryOperatorType.LogicalAnd, BinaryOperatorType.LogicalOr },
-			new BinaryOperatorType[] { BinaryOperatorType.NullCoalescing }
-		);
-		
-		// create a dictionary operator->precedence (higher value = higher precedence)
-		static Dictionary<BinaryOperatorType, int> MakePrecedenceTable(params BinaryOperatorType[][] input)
-		{
-			Dictionary<BinaryOperatorType, int> dict = new Dictionary<BinaryOperatorType, int>();
-			for (int i = 0; i < input.Length; i++) {
-				foreach (BinaryOperatorType op in input[i]) {
-					dict.Add(op, input.Length - i);
-				}
-			}
-			return dict;
-		}
-		
-		public static int ComparePrecedenceVB(BinaryOperatorType op1, BinaryOperatorType op2)
-		{
-			int p1 = GetOperatorPrecedence(vbDict, op1);
-			int p2 = GetOperatorPrecedence(vbDict, op2);
-			return p1.CompareTo(p2);
-		}
-		
-		public static int ComparePrecedenceCSharp(BinaryOperatorType op1, BinaryOperatorType op2)
-		{
-			int p1 = GetOperatorPrecedence(csharpDict, op1);
-			int p2 = GetOperatorPrecedence(csharpDict, op2);
-			return p1.CompareTo(p2);
-		}
-		
-		static int GetOperatorPrecedence(Dictionary<BinaryOperatorType, int> dict, BinaryOperatorType op)
-		{
-			int p;
-			dict.TryGetValue(op, out p);
-			return p;
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/IOutputFormatter.cs b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/IOutputFormatter.cs
new file mode 100644
index 000000000..a544eb0d0
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/IOutputFormatter.cs
@@ -0,0 +1,39 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	/// <summary>
+	/// Output formatter for the Output visitor.
+	/// </summary>
+	public interface IOutputFormatter
+	{
+		void StartNode(AstNode node);
+		void EndNode(AstNode node);
+		
+		/// <summary>
+		/// Writes an identifier.
+		/// If the identifier conflicts with a keyword, the output visitor will
+		/// call <c>WriteToken("@")</c> before calling WriteIdentifier().
+		/// </summary>
+		void WriteIdentifier(string identifier);
+		
+		/// <summary>
+		/// Writes a keyword to the output.
+		/// </summary>
+		void WriteKeyword(string keyword);
+		
+		/// <summary>
+		/// Writes a token to the output.
+		/// </summary>
+		void WriteToken(string token);
+		void Space();
+		
+		void Indent();
+		void Unindent();
+		
+		void NewLine();
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs
new file mode 100644
index 000000000..f4085b6bc
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/OutputVisitor.cs
@@ -0,0 +1,222 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+using ICSharpCode.NRefactory.PatternMatching;
+using ICSharpCode.NRefactory.VB.Ast;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	/// <summary>
+	/// Description of OutputVisitor.
+	/// </summary>
+	public class OutputVisitor : IAstVisitor<object, object>, IPatternAstVisitor<object, object>
+	{
+		readonly IOutputFormatter formatter;
+		readonly VBFormattingOptions policy;
+		
+		readonly Stack<AstNode> containerStack = new Stack<AstNode>();
+		readonly Stack<AstNode> positionStack = new Stack<AstNode>();
+		
+		public OutputVisitor(TextWriter textWriter, VBFormattingOptions formattingPolicy)
+		{
+			if (textWriter == null)
+				throw new ArgumentNullException("textWriter");
+			if (formattingPolicy == null)
+				throw new ArgumentNullException("formattingPolicy");
+			this.formatter = new TextWriterOutputFormatter(textWriter);
+			this.policy = formattingPolicy;
+		}
+		
+		public OutputVisitor(IOutputFormatter formatter, VBFormattingOptions formattingPolicy)
+		{
+			if (formatter == null)
+				throw new ArgumentNullException("formatter");
+			if (formattingPolicy == null)
+				throw new ArgumentNullException("formattingPolicy");
+			this.formatter = formatter;
+			this.policy = formattingPolicy;
+		}
+		
+		public object VisitCompilationUnit(ICSharpCode.NRefactory.VB.Ast.CompilationUnit compilationUnit, object data)
+		{
+			// don't do node tracking as we visit all children directly
+			foreach (AstNode node in compilationUnit.Children)
+				node.AcceptVisitor(this, data);
+			return null;
+		}
+		
+		public object VisitBlockStatement(BlockStatement blockStatement, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitPatternPlaceholder(AstNode placeholder, Pattern pattern, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitTypeParameterDeclaration(TypeParameterDeclaration typeParameterDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitParameterDeclaration(ParameterDeclaration parameterDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitVBTokenNode(VBTokenNode vBTokenNode, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitAliasImportsClause(AliasImportsClause aliasImportsClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitAttributeBlock(AttributeBlock attributeBlock, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitImportsStatement(ImportsStatement importsStatement, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitMembersImportsClause(MemberImportsClause membersImportsClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitOptionStatement(OptionStatement optionStatement, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitXmlNamespaceImportsClause(XmlNamespaceImportsClause xmlNamespaceImportsClause, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitEnumDeclaration(EnumDeclaration enumDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitEnumMemberDeclaration(EnumMemberDeclaration enumMemberDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitIdentifier(Identifier identifier, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitXmlIdentifier(XmlIdentifier xmlIdentifier, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitXmlLiteralString(XmlLiteralString xmlLiteralString, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitSimpleNameExpression(SimpleNameExpression identifierExpression, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitPrimitiveType(PrimitiveType primitiveType, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitQualifiedType(QualifiedType qualifiedType, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitComposedType(ComposedType composedType, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitArraySpecifier(ArraySpecifier arraySpecifier, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitSimpleType(SimpleType simpleType, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitAnyNode(AnyNode anyNode, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitBackreference(Backreference backreference, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitChoice(Choice choice, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitNamedNode(NamedNode namedNode, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitRepeat(Repeat repeat, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitOptionalNode(OptionalNode optionalNode, object data)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public object VisitIdentifierExpressionBackreference(IdentifierExpressionBackreference identifierExpressionBackreference, object data)
+		{
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/TextWriterOutputFormatter.cs b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/TextWriterOutputFormatter.cs
new file mode 100644
index 000000000..cc2df64ed
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/TextWriterOutputFormatter.cs
@@ -0,0 +1,83 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.IO;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	/// <summary>
+	/// Writes VB code into a TextWriter.
+	/// </summary>
+	public class TextWriterOutputFormatter : IOutputFormatter
+	{
+		readonly TextWriter textWriter;
+		int indentation;
+		bool needsIndent = true;
+		
+		public TextWriterOutputFormatter(TextWriter textWriter)
+		{
+			if (textWriter == null)
+				throw new ArgumentNullException("textWriter");
+			this.textWriter = textWriter;
+		}
+		
+		public void WriteIdentifier(string ident)
+		{
+			WriteIndentation();
+			textWriter.Write(ident);
+		}
+		
+		public void WriteKeyword(string keyword)
+		{
+			WriteIndentation();
+			textWriter.Write(keyword);
+		}
+		
+		public void WriteToken(string token)
+		{
+			WriteIndentation();
+			textWriter.Write(token);
+		}
+		
+		public void Space()
+		{
+			WriteIndentation();
+			textWriter.Write(' ');
+		}
+		
+		void WriteIndentation()
+		{
+			if (needsIndent) {
+				needsIndent = false;
+				for (int i = 0; i < indentation; i++) {
+					textWriter.Write('\t');
+				}
+			}
+		}
+		
+		public void NewLine()
+		{
+			textWriter.WriteLine();
+			needsIndent = true;
+		}
+		
+		public void Indent()
+		{
+			indentation++;
+		}
+		
+		public void Unindent()
+		{
+			indentation--;
+		}
+		
+		public virtual void StartNode(AstNode node)
+		{
+		}
+		
+		public virtual void EndNode(AstNode node)
+		{
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/VBFormattingOptions.cs b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/VBFormattingOptions.cs
new file mode 100644
index 000000000..8888bf2ff
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/OutputVisitor/VBFormattingOptions.cs
@@ -0,0 +1,17 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	/// <summary>
+	/// Description of VBFormattingOptions.
+	/// </summary>
+	public class VBFormattingOptions
+	{
+		public VBFormattingOptions()
+		{
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Parser/ModifierList.cs b/NRefactory/ICSharpCode.NRefactory.VB/Parser/ModifierList.cs
deleted file mode 100644
index 7acfedbae..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Parser/ModifierList.cs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Parser
-{
-	internal class ModifierList
-	{
-		Modifiers cur;
-		Location location = new Location(-1, -1);
-		
-		public Modifiers Modifier {
-			get {
-				return cur;
-			}
-		}
-		
-		public Location GetDeclarationLocation(Location keywordLocation)
-		{
-			if(location.IsEmpty) {
-				return keywordLocation;
-			}
-			return location;
-		}
-		
-//		public Location Location {
-//			get {
-//				return location;
-//			}
-//			set {
-//				location = value;
-//			}
-//		}
-		
-		public bool isNone { get { return cur == Modifiers.None; } }
-		
-		public bool Contains(Modifiers m)
-		{
-			return ((cur & m) != 0);
-		}
-		
-		public void Add(Modifiers m, Location tokenLocation) 
-		{
-			if(location.IsEmpty) {
-				location = tokenLocation;
-			}
-			
-			if ((cur & m) == 0) {
-				cur |= m;
-			} else {
-//				parser.Error("modifier " + m + " already defined");
-			}
-		}
-		
-//		public void Add(Modifiers m)
-//		{
-//			Add(m.cur, m.Location);
-//		}
-		
-		public void Check(Modifiers allowed)
-		{
-			Modifiers wrong = cur & ~allowed;
-			if (wrong != Modifiers.None) {
-//				parser.Error("modifier(s) " + wrong + " not allowed here");
-			}
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Parser/ParamModifierList.cs b/NRefactory/ICSharpCode.NRefactory.VB/Parser/ParamModifierList.cs
deleted file mode 100644
index f9a6c6dd9..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Parser/ParamModifierList.cs
+++ /dev/null
@@ -1,49 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Parser
-{
-	internal class ParamModifierList
-	{
-		ParameterModifiers cur;
-		VBParser   parser;
-		
-		public ParameterModifiers Modifier {
-			get {
-				return cur;
-			}
-		}
-		
-		public ParamModifierList(VBParser parser)
-		{
-			this.parser = parser;
-			cur         = ParameterModifiers.None;
-		}
-		
-		public bool isNone { get { return cur == ParameterModifiers.None; } }
-		
-		public void Add(ParameterModifiers m) 
-		{
-			if ((cur & m) == 0) {
-				cur |= m;
-			} else {
-				parser.Error("param modifier " + m + " already defined");
-			}
-		}
-		
-		public void Add(ParamModifierList m)
-		{
-			Add(m.cur);
-		}
-		
-		public void Check()
-		{
-			if((cur & ParameterModifiers.In) != 0 && 
-			   (cur & ParameterModifiers.Ref) != 0) {
-				parser.Error("ByRef and ByVal are not allowed at the same time.");
-			}
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Parser/Parser.cs b/NRefactory/ICSharpCode.NRefactory.VB/Parser/Parser.cs
index 88ff84b89..1b2b8d939 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Parser/Parser.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Parser/Parser.cs
@@ -7,6 +7,7 @@ using System.Text;
 using ICSharpCode.NRefactory.VB.Ast;
 using ICSharpCode.NRefactory.VB.Parser;
 using ASTAttribute = ICSharpCode.NRefactory.VB.Ast.Attribute;
+using Roles = ICSharpCode.NRefactory.VB.AstNode.Roles;
 
 
 
@@ -41,7 +42,6 @@ partial class VBParser
 	public const int _XmlCData = 18;
 	public const int _XmlProcessingInstruction = 19;
 	public const int maxT = 238;  //<! max term (w/o pragmas)
-	public const int StatementEndOfStmt = 1;
 
 	const bool T = true;
 	const bool x = false;
@@ -86,5003 +86,391 @@ partial class VBParser
 
 
 	void VB() {
-		lexer.NextToken(); // get the first token
 		compilationUnit = new CompilationUnit();
-		BlockStart(compilationUnit);
+			NodeStart(compilationUnit);
+			Get();
 
 		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
+			StatementTerminator();
 		}
 		while (la.kind == 173) {
-			OptionStmt();
+			OptionStatement(CompilationUnit.MemberRole);
 			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
+				StatementTerminator();
 			}
 		}
 		while (la.kind == 137) {
-			ImportsStmt();
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
-		}
-		while (IsGlobalAttrTarget()) {
-			GlobalAttributeSection();
+			ImportsStatement(CompilationUnit.MemberRole);
 			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
-		}
-		while (StartOf(2)) {
-			NamespaceMemberDecl();
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
+				StatementTerminator();
 			}
 		}
 	}
 
-	void EndOfStmt() {
+	void StatementTerminator() {
 		while (!(la.kind == 0 || la.kind == 1 || la.kind == 21)) {SynErr(239); Get();}
 		if (la.kind == 1) {
 			Get();
+			AddTerminal(Roles.StatementTerminator);
 		} else if (la.kind == 21) {
 			Get();
+			AddTerminal(Roles.StatementTerminator);
 		} else SynErr(240);
 	}
 
-	void OptionStmt() {
-		INode node = null; bool val = true;
+	void OptionStatement(Role role) {
+		var result = new OptionStatement(); NodeStart(result);
 		Expect(173);
-		Location startPos = t.Location;
+		AddTerminal(Roles.Keyword);
 		if (la.kind == 121) {
 			Get();
+			AddTerminal(Ast.OptionStatement.OptionTypeRole);
+			result.OptionType = OptionType.Explicit;
 			if (la.kind == 170 || la.kind == 171) {
-				OptionValue(ref val);
+				OnOff(result);
 			}
-			node = new OptionDeclaration(OptionType.Explicit, val);
 		} else if (la.kind == 207) {
 			Get();
+			AddTerminal(Ast.OptionStatement.OptionTypeRole);
+			result.OptionType = OptionType.Strict;
 			if (la.kind == 170 || la.kind == 171) {
-				OptionValue(ref val);
+				OnOff(result);
 			}
-			node = new OptionDeclaration(OptionType.Strict, val);
-		} else if (la.kind == 87) {
-			Get();
-			if (la.kind == 67) {
-				Get();
-				node = new OptionDeclaration(OptionType.CompareBinary, val);
-			} else if (la.kind == 213) {
-				Get();
-				node = new OptionDeclaration(OptionType.CompareText, val);
-			} else SynErr(241);
 		} else if (la.kind == 139) {
 			Get();
+			AddTerminal(Ast.OptionStatement.OptionTypeRole);
+			result.OptionType = OptionType.Infer;
 			if (la.kind == 170 || la.kind == 171) {
-				OptionValue(ref val);
-			}
-			node = new OptionDeclaration(OptionType.Infer, val);
-		} else SynErr(242);
-		EndOfStmt();
-		if (node != null) {
-				node.StartLocation = startPos;
-				node.EndLocation   = t.Location;
-				AddChild(node);
+				OnOff(result);
 			}
-
+		} else if (la.kind == 87) {
+			Get();
+			AddTerminal(Ast.OptionStatement.OptionTypeRole);
+			result.OptionType = OptionType.Compare;
+			BinaryText(result);
+		} else SynErr(241);
+		StatementTerminator();
+		NodeEnd(result, role);
 	}
 
-	void ImportsStmt() {
-		List<Using> usings = new List<Using>();
-
+	void ImportsStatement(Role role) {
+		var result = new ImportsStatement(); NodeStart(result);
 		Expect(137);
-		Location startPos = t.Location;
-			Using u;
-
-		ImportClause(out u);
-		if (u != null) { usings.Add(u); }
+		AddTerminal(Roles.Keyword);
+		ImportsClause();
 		while (la.kind == 22) {
 			Get();
-			ImportClause(out u);
-			if (u != null) { usings.Add(u); }
-		}
-		EndOfStmt();
-		UsingDeclaration usingDeclaration = new UsingDeclaration(usings);
-			usingDeclaration.StartLocation = startPos;
-			usingDeclaration.EndLocation   = t.Location;
-			AddChild(usingDeclaration);
-
-	}
-
-	void GlobalAttributeSection() {
-		Expect(40);
-		Location startPos = t.Location;
-		if (la.kind == 65) {
-			Get();
-		} else if (la.kind == 155) {
-			Get();
-		} else SynErr(243);
-		string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
-			List<ASTAttribute> attributes = new List<ASTAttribute>();
-			ASTAttribute attribute;
-
-		Expect(21);
-		Attribute(out attribute);
-		attributes.Add(attribute);
-		while (NotFinalComma()) {
-			if (la.kind == 22) {
-				Get();
-				if (la.kind == 65) {
-					Get();
-				} else if (la.kind == 155) {
-					Get();
-				} else SynErr(244);
-				Expect(21);
-			}
-			Attribute(out attribute);
-			attributes.Add(attribute);
-		}
-		if (la.kind == 22) {
-			Get();
-		}
-		Expect(39);
-		EndOfStmt();
-		AttributeSection section = new AttributeSection {
-				AttributeTarget = attributeTarget,
-				Attributes = attributes,
-				StartLocation = startPos,
-				EndLocation = t.EndLocation
-			};
-			AddChild(section);
-
-	}
-
-	void NamespaceMemberDecl() {
-		ModifierList m = new ModifierList();
-		AttributeSection section;
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		string qualident;
-
-		if (la.kind == 160) {
-			Get();
-			Location startPos = t.Location;
-
-			Qualident(out qualident);
-			INode node =  new NamespaceDeclaration(qualident);
-				node.StartLocation = startPos;
-				AddChild(node);
-				BlockStart(node);
-
-			EndOfStmt();
-			NamespaceBody();
-			node.EndLocation = t.Location;
-				BlockEnd();
-
-		} else if (StartOf(3)) {
-			while (la.kind == 40) {
-				AttributeSection(out section);
-				attributes.Add(section);
-			}
-			while (StartOf(4)) {
-				TypeModifier(m);
-			}
-			NonModuleDeclaration(m, attributes);
-		} else SynErr(245);
-	}
-
-	void OptionValue(ref bool val) {
-		if (la.kind == 171) {
-			Get();
-			val = true;
-		} else if (la.kind == 170) {
-			Get();
-			val = false;
-		} else SynErr(246);
-	}
-
-	void ImportClause(out Using u) {
-		string qualident  = null;
-		TypeReference aliasedType = null;
-		u = null;
-
-		if (StartOf(5)) {
-			Qualident(out qualident);
-			if (la.kind == 20) {
-				Get();
-				TypeName(out aliasedType);
-			}
-			if (qualident != null && qualident.Length > 0) {
-					if (aliasedType != null) {
-						u = new Using(qualident, aliasedType);
-					} else {
-						u = new Using(qualident);
-					}
-				}
-
-		} else if (la.kind == 10) {
-			string prefix = null;
-			Get();
-			Identifier();
-			prefix = t.val;
-			Expect(20);
-			Expect(3);
-			u = new Using(t.literalValue as string, prefix);
-			Expect(11);
-		} else SynErr(247);
-	}
-
-	void Qualident(out string qualident) {
-		string name;
-		qualidentBuilder.Length = 0; 
-
-		Identifier();
-		qualidentBuilder.Append(t.val);
-		while (DotAndIdentOrKw()) {
-			Expect(26);
-			IdentifierOrKeyword(out name);
-			qualidentBuilder.Append('.'); qualidentBuilder.Append(name);
+			ImportsClause();
 		}
-		qualident = qualidentBuilder.ToString();
-	}
-
-	void TypeName(out TypeReference typeref) {
-		ArrayList rank = null; Location startLocation = la.Location;
-		NonArrayTypeName(out typeref, false);
-		ArrayTypeModifiers(out rank);
-		if (typeref != null) {
-				if (rank != null) {
-					typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
-				}
-				typeref.StartLocation = startLocation;
-				typeref.EndLocation = t.EndLocation;
-			}
-
+		StatementTerminator();
+		NodeEnd(result, role);
 	}
 
 	void Identifier() {
-		if (StartOf(6)) {
+		if (StartOf(1)) {
 			IdentifierForFieldDeclaration();
 		} else if (la.kind == 98) {
 			Get();
-		} else SynErr(248);
-	}
-
-	void NamespaceBody() {
-		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-		}
-		while (StartOf(2)) {
-			NamespaceMemberDecl();
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
-		}
-		Expect(113);
-		Expect(160);
-		EndOfStmt();
-	}
-
-	void AttributeSection(out AttributeSection section) {
-		string attributeTarget = "";
-		List<ASTAttribute> attributes = new List<ASTAttribute>();
-		ASTAttribute attribute;
-		Location startLocation = la.Location;
-
-		Expect(40);
-		if (IsLocalAttrTarget()) {
-			if (la.kind == 119) {
-				Get();
-				attributeTarget = "event";
-			} else if (la.kind == 195) {
-				Get();
-				attributeTarget = "return";
-			} else if (StartOf(5)) {
-				Identifier();
-				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
-					if (val != "field"	|| val != "method" ||
-						val != "module" || val != "param"  ||
-						val != "property" || val != "type")
-					Error("attribute target specifier (event, return, field," +
-							"method, module, param, property, or type) expected");
-					attributeTarget = t.val;
-
-			} else SynErr(249);
-			Expect(21);
-		}
-		Attribute(out attribute);
-		attributes.Add(attribute);
-		while (NotFinalComma()) {
-			Expect(22);
-			Attribute(out attribute);
-			attributes.Add(attribute);
-		}
-		if (la.kind == 22) {
-			Get();
-		}
-		Expect(39);
-		section = new AttributeSection {
-				AttributeTarget = attributeTarget,
-				Attributes = attributes,
-				StartLocation = startLocation,
-				EndLocation = t.EndLocation
-			};
-
+		} else SynErr(242);
 	}
 
-	void TypeModifier(ModifierList m) {
+	void IdentifierForFieldDeclaration() {
 		switch (la.kind) {
-		case 188: {
+		case 2: {
 			Get();
-			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
-		case 187: {
+		case 58: {
 			Get();
-			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
-		case 125: {
+		case 62: {
 			Get();
-			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
-		case 185: {
+		case 64: {
 			Get();
-			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
-		case 200: {
+		case 65: {
 			Get();
-			m.Add(Modifiers.Static, t.Location);
 			break;
 		}
-		case 199: {
+		case 66: {
 			Get();
-			m.Add(Modifiers.New, t.Location);
 			break;
 		}
-		case 156: {
+		case 67: {
 			Get();
-			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
-		case 166: {
+		case 70: {
 			Get();
-			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
-		case 183: {
+		case 87: {
 			Get();
-			m.Add(Modifiers.Partial, t.Location);
 			break;
 		}
-		default: SynErr(250); break;
-		}
-	}
-
-	void NonModuleDeclaration(ModifierList m, List<AttributeSection> attributes) {
-		TypeReference typeRef = null;
-		List<TypeReference> baseInterfaces = null;
-
-		switch (la.kind) {
-		case 84: {
-			m.Check(Modifiers.Classes);
+		case 104: {
 			Get();
-			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-				newType.StartLocation = t.Location;
-				AddChild(newType);
-				BlockStart(newType);
-				
-				newType.Type       = ClassType.Class;
-
-			Identifier();
-			newType.Name = t.val;
-			TypeParameterList(newType.Templates);
-			EndOfStmt();
-			newType.BodyStartLocation = t.Location;
-			if (la.kind == 140) {
-				ClassBaseType(out typeRef);
-				SafeAdd(newType, newType.BaseTypes, typeRef);
-			}
-			while (la.kind == 136) {
-				TypeImplementsClause(out baseInterfaces);
-				newType.BaseTypes.AddRange(baseInterfaces);
-			}
-			ClassBody(newType);
-			Expect(113);
-			Expect(84);
-			newType.EndLocation = t.EndLocation;
-			EndOfStmt();
-			BlockEnd();
-
 			break;
 		}
-		case 155: {
+		case 107: {
 			Get();
-			m.Check(Modifiers.VBModules);
-				TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-				AddChild(newType);
-				BlockStart(newType);
-				newType.StartLocation = m.GetDeclarationLocation(t.Location);
-				newType.Type = ClassType.Module;
-
-			Identifier();
-			newType.Name = t.val;
-			EndOfStmt();
-			newType.BodyStartLocation = t.Location;
-			ModuleBody(newType);
-			BlockEnd();
-
 			break;
 		}
-		case 209: {
+		case 116: {
 			Get();
-			m.Check(Modifiers.VBStructures);
-				TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-				AddChild(newType);
-				BlockStart(newType);
-				newType.StartLocation = m.GetDeclarationLocation(t.Location);
-				newType.Type = ClassType.Struct;
-
-			Identifier();
-			newType.Name = t.val;
-			TypeParameterList(newType.Templates);
-			EndOfStmt();
-			newType.BodyStartLocation = t.Location;
-			while (la.kind == 136) {
-				TypeImplementsClause(out baseInterfaces);
-				newType.BaseTypes.AddRange(baseInterfaces);
-			}
-			StructureBody(newType);
-			BlockEnd();
-
 			break;
 		}
-		case 115: {
+		case 121: {
 			Get();
-			m.Check(Modifiers.VBEnums);
-				TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-				newType.StartLocation = m.GetDeclarationLocation(t.Location);
-				AddChild(newType);
-				BlockStart(newType);
-				
-				newType.Type = ClassType.Enum;
-
-			Identifier();
-			newType.Name = t.val;
-			if (la.kind == 63) {
-				Get();
-				NonArrayTypeName(out typeRef, false);
-				SafeAdd(newType, newType.BaseTypes, typeRef);
-			}
-			EndOfStmt();
-			newType.BodyStartLocation = t.Location;
-			EnumBody(newType);
-			BlockEnd();
-
 			break;
 		}
-		case 142: {
+		case 126: {
 			Get();
-			m.Check(Modifiers.VBInterfacs);
-				TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-				newType.StartLocation = m.GetDeclarationLocation(t.Location);
-				AddChild(newType);
-				BlockStart(newType);
-				newType.Type = ClassType.Interface;
-
-			Identifier();
-			newType.Name = t.val;
-			TypeParameterList(newType.Templates);
-			EndOfStmt();
-			newType.BodyStartLocation = t.Location;
-			while (la.kind == 140) {
-				InterfaceBase(out baseInterfaces);
-				newType.BaseTypes.AddRange(baseInterfaces);
-			}
-			InterfaceBody(newType);
-			BlockEnd();
-
 			break;
 		}
-		case 103: {
+		case 133: {
 			Get();
-			m.Check(Modifiers.VBDelegates);
-				DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);
-				delegateDeclr.ReturnType = new TypeReference("System.Void", true);
-				delegateDeclr.StartLocation = m.GetDeclarationLocation(t.Location);
-				List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-
-			if (la.kind == 210) {
-				Get();
-				Identifier();
-				delegateDeclr.Name = t.val;
-				TypeParameterList(delegateDeclr.Templates);
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-					delegateDeclr.Parameters = p;
-				}
-			} else if (la.kind == 127) {
-				Get();
-				Identifier();
-				delegateDeclr.Name = t.val;
-				TypeParameterList(delegateDeclr.Templates);
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-					delegateDeclr.Parameters = p;
-				}
-				if (la.kind == 63) {
-					Get();
-					TypeReference type;
-					TypeName(out type);
-					delegateDeclr.ReturnType = type;
-				}
-			} else SynErr(251);
-			delegateDeclr.EndLocation = t.EndLocation;
-			EndOfStmt();
-			AddChild(delegateDeclr);
-
 			break;
 		}
-		default: SynErr(252); break;
-		}
-	}
-
-	void TypeParameterList(List<TemplateDefinition> templates) {
-		TemplateDefinition template;
-
-		if (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
-			Expect(37);
-			Expect(169);
-			TypeParameter(out template);
-			if (template != null) templates.Add(template);
-
-			while (la.kind == 22) {
-				Get();
-				TypeParameter(out template);
-				if (template != null) templates.Add(template);
-
-			}
-			Expect(38);
-		}
-	}
-
-	void TypeParameter(out TemplateDefinition template) {
-		VarianceModifier modifier = VarianceModifier.Invariant; Location startLocation = la.Location;
-		if (la.kind == 138 || (la.kind == Tokens.Out && IsIdentifierToken(Peek(1)))) {
-			if (la.kind == 138) {
-				Get();
-				modifier = VarianceModifier.Contravariant;
-			} else {
-				Expect(178);
-				modifier = VarianceModifier.Covariant;
-			}
-		}
-		Identifier();
-		template = new TemplateDefinition(t.val, null) { VarianceModifier = modifier };
-		if (la.kind == 63) {
-			TypeParameterConstraints(template);
-		}
-		if (template != null) {
-				template.StartLocation = startLocation;
-				template.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void TypeParameterConstraints(TemplateDefinition template) {
-		TypeReference constraint;
-
-		Expect(63);
-		if (la.kind == 35) {
-			Get();
-			TypeParameterConstraint(out constraint);
-			if (constraint != null) { template.Bases.Add(constraint); }
-			while (la.kind == 22) {
-				Get();
-				TypeParameterConstraint(out constraint);
-				if (constraint != null) { template.Bases.Add(constraint); }
-			}
-			Expect(36);
-		} else if (StartOf(8)) {
-			TypeParameterConstraint(out constraint);
-			if (constraint != null) { template.Bases.Add(constraint); }
-		} else SynErr(253);
-	}
-
-	void TypeParameterConstraint(out TypeReference constraint) {
-		constraint = null; Location startLocation = la.Location;
-		if (la.kind == 84) {
-			Get();
-			constraint = TypeReference.ClassConstraint;
-		} else if (la.kind == 209) {
-			Get();
-			constraint = TypeReference.StructConstraint;
-		} else if (la.kind == 162) {
-			Get();
-			constraint = TypeReference.NewConstraint;
-		} else if (StartOf(9)) {
-			TypeName(out constraint);
-		} else SynErr(254);
-	}
-
-	void ClassBaseType(out TypeReference typeRef) {
-		typeRef = null;
-
-		Expect(140);
-		TypeName(out typeRef);
-		EndOfStmt();
-	}
-
-	void TypeImplementsClause(out List<TypeReference> baseInterfaces) {
-		baseInterfaces = new List<TypeReference>();
-		TypeReference type = null;
-
-		Expect(136);
-		TypeName(out type);
-		if (type != null) baseInterfaces.Add(type);
-
-		while (la.kind == 22) {
-			Get();
-			TypeName(out type);
-			if (type != null) baseInterfaces.Add(type);
-		}
-		EndOfStmt();
-	}
-
-	void ClassBody(TypeDeclaration newType) {
-		AttributeSection section;
-		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-		}
-		while (StartOf(10)) {
-			List<AttributeSection> attributes = new List<AttributeSection>();
-				ModifierList m = new ModifierList();
-
-			while (la.kind == 40) {
-				AttributeSection(out section);
-				attributes.Add(section);
-			}
-			while (StartOf(11)) {
-				MemberModifier(m);
-			}
-			ClassMemberDecl(m, attributes);
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
-		}
-	}
-
-	void ModuleBody(TypeDeclaration newType) {
-		AttributeSection section;
-		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-		}
-		while (StartOf(10)) {
-			List<AttributeSection> attributes = new List<AttributeSection>();
-				ModifierList m = new ModifierList();
-
-			while (la.kind == 40) {
-				AttributeSection(out section);
-				attributes.Add(section);
-			}
-			while (StartOf(11)) {
-				MemberModifier(m);
-			}
-			ClassMemberDecl(m, attributes);
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
-		}
-		Expect(113);
-		Expect(155);
-		newType.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void StructureBody(TypeDeclaration newType) {
-		AttributeSection section;
-		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-		}
-		while (StartOf(10)) {
-			List<AttributeSection> attributes = new List<AttributeSection>();
-				ModifierList m = new ModifierList();
-
-			while (la.kind == 40) {
-				AttributeSection(out section);
-				attributes.Add(section);
-			}
-			while (StartOf(11)) {
-				MemberModifier(m);
-			}
-			StructureMemberDecl(m, attributes);
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
-		}
-		Expect(113);
-		Expect(209);
-		newType.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void NonArrayTypeName(out TypeReference typeref, bool canBeUnbound) {
-		string name;
-		typeref = null;
-		bool isGlobal = false;
-
-		if (StartOf(12)) {
-			if (la.kind == 130) {
-				Get();
-				Expect(26);
-				isGlobal = true;
-			}
-			QualIdentAndTypeArguments(out typeref, canBeUnbound);
-			typeref.IsGlobal = isGlobal;
-			while (la.kind == 26) {
-				Get();
-				TypeReference nestedTypeRef;
-				QualIdentAndTypeArguments(out nestedTypeRef, canBeUnbound);
-				typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes);
-			}
-		} else if (la.kind == 168) {
+		case 139: {
 			Get();
-			typeref = new TypeReference("System.Object", true);
-			if (la.kind == 33) {
-				Get();
-				List<TypeReference> typeArguments = new List<TypeReference>(1);
-				  	if (typeref != null) typeArguments.Add(typeref);
-					typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
-
-			}
-		} else if (StartOf(13)) {
-			PrimitiveTypeName(out name);
-			typeref = new TypeReference(name, true);
-			if (la.kind == 33) {
-				Get();
-				List<TypeReference> typeArguments = new List<TypeReference>(1);
-				  	if (typeref != null) typeArguments.Add(typeref);
-					typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
-
-			}
-		} else SynErr(255);
-	}
-
-	void EnumBody(TypeDeclaration newType) {
-		FieldDeclaration f;
-		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-		}
-		while (StartOf(14)) {
-			EnumMemberDecl(out f);
-			AddChild(f);
-
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
+			break;
 		}
-		Expect(113);
-		Expect(115);
-		newType.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void InterfaceBase(out List<TypeReference> bases) {
-		TypeReference type;
-		bases = new List<TypeReference>();
-
-		Expect(140);
-		TypeName(out type);
-		if (type != null) bases.Add(type);
-		while (la.kind == 22) {
+		case 143: {
 			Get();
-			TypeName(out type);
-			if (type != null) bases.Add(type);
-		}
-		EndOfStmt();
-	}
-
-	void InterfaceBody(TypeDeclaration newType) {
-		while (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-		}
-		while (StartOf(15)) {
-			InterfaceMemberDecl();
-			while (la.kind == 1 || la.kind == 21) {
-				EndOfStmt();
-			}
+			break;
 		}
-		Expect(113);
-		Expect(142);
-		newType.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void FormalParameterList(List<ParameterDeclarationExpression> parameter) {
-		ParameterDeclarationExpression p;
-		FormalParameter(out p);
-		if (p != null) parameter.Add(p);
-		while (la.kind == 22) {
+		case 146: {
 			Get();
-			FormalParameter(out p);
-			if (p != null) parameter.Add(p);
+			break;
 		}
-	}
-
-	void MemberModifier(ModifierList m) {
-		switch (la.kind) {
-		case 156: {
+		case 147: {
 			Get();
-			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
-		case 102: {
+		case 170: {
 			Get();
-			m.Add(Modifiers.Default, t.Location);
 			break;
 		}
-		case 125: {
+		case 176: {
 			Get();
-			m.Add(Modifiers.Internal, t.Location);
 			break;
 		}
-		case 199: {
+		case 178: {
 			Get();
-			m.Add(Modifiers.New, t.Location);
 			break;
 		}
-		case 181: {
+		case 184: {
 			Get();
-			m.Add(Modifiers.Override, t.Location);
 			break;
 		}
-		case 157: {
+		case 203: {
 			Get();
-			m.Add(Modifiers.Abstract, t.Location);
 			break;
 		}
-		case 185: {
+		case 212: {
 			Get();
-			m.Add(Modifiers.Private, t.Location);
 			break;
 		}
-		case 187: {
+		case 213: {
 			Get();
-			m.Add(Modifiers.Protected, t.Location);
 			break;
 		}
-		case 188: {
+		case 223: {
 			Get();
-			m.Add(Modifiers.Public, t.Location);
 			break;
 		}
-		case 166: {
+		case 224: {
 			Get();
-			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
-		case 167: {
+		case 230: {
 			Get();
-			m.Add(Modifiers.Sealed, t.Location);
 			break;
 		}
-		case 200: {
-			Get();
-			m.Add(Modifiers.Static, t.Location);
-			break;
-		}
-		case 180: {
-			Get();
-			m.Add(Modifiers.Virtual, t.Location);
-			break;
-		}
-		case 179: {
-			Get();
-			m.Add(Modifiers.Overloads, t.Location);
-			break;
-		}
-		case 190: {
-			Get();
-			m.Add(Modifiers.ReadOnly, t.Location);
-			break;
-		}
-		case 235: {
-			Get();
-			m.Add(Modifiers.WriteOnly, t.Location);
-			break;
-		}
-		case 234: {
-			Get();
-			m.Add(Modifiers.WithEvents, t.Location);
-			break;
-		}
-		case 105: {
-			Get();
-			m.Add(Modifiers.Dim, t.Location);
-			break;
-		}
-		case 183: {
-			Get();
-			m.Add(Modifiers.Partial, t.Location);
-			break;
-		}
-		default: SynErr(256); break;
-		}
-	}
-
-	void ClassMemberDecl(ModifierList m, List<AttributeSection> attributes) {
-		StructureMemberDecl(m, attributes);
-	}
-
-	void StructureMemberDecl(ModifierList m, List<AttributeSection> attributes) {
-		TypeReference type = null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		Statement stmt = null;
-		List<VariableDeclaration> variableDeclarators = new List<VariableDeclaration>();
-		List<TemplateDefinition> templates = new List<TemplateDefinition>();
-
-		switch (la.kind) {
-		case 84: case 103: case 115: case 142: case 155: case 209: {
-			NonModuleDeclaration(m, attributes);
-			break;
-		}
-		case 210: {
-			Get();
-			Location startPos = t.Location;
-
-			if (StartOf(5)) {
-				string name = String.Empty;
-					MethodDeclaration methodDeclaration; List<string> handlesClause = null;
-					List<InterfaceImplementation> implementsClause = null;
-
-				Identifier();
-				name = t.val;
-					m.Check(Modifiers.VBMethods);
-
-				TypeParameterList(templates);
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				if (la.kind == 134 || la.kind == 136) {
-					if (la.kind == 136) {
-						ImplementsClause(out implementsClause);
-					} else {
-						HandlesClause(out handlesClause);
-					}
-				}
-				Location endLocation = t.EndLocation;
-				if (IsMustOverride(m)) {
-					EndOfStmt();
-					methodDeclaration = new MethodDeclaration {
-							Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
-							StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
-							TypeReference = new TypeReference("System.Void", true),
-							Templates = templates,
-							HandlesClause = handlesClause,
-							InterfaceImplementations = implementsClause
-						};
-						AddChild(methodDeclaration);
-
-				} else if (la.kind == 1) {
-					Get();
-					methodDeclaration = new MethodDeclaration {
-							Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
-							StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
-							TypeReference = new TypeReference("System.Void", true),
-							Templates = templates,
-							HandlesClause = handlesClause,
-							InterfaceImplementations = implementsClause
-						};
-						AddChild(methodDeclaration);
-
-					if (ParseMethodBodies) {
-					Block(out stmt);
-					Expect(113);
-					Expect(210);
-					} else {
-						// don't parse method body
-						lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
-					   }
-
-					methodDeclaration.Body  = (BlockStatement)stmt;
-					methodDeclaration.Body.EndLocation = t.EndLocation;
-					EndOfStmt();
-				} else SynErr(257);
-			} else if (la.kind == 162) {
-				Get();
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				m.Check(Modifiers.Constructors);
-				Location constructorEndLocation = t.EndLocation;
-				Expect(1);
-				if (ParseMethodBodies) {
-				Block(out stmt);
-				Expect(113);
-				Expect(210);
-				} else {
-					// don't parse method body
-					lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
-				   }
-
-				Location endLocation = t.EndLocation;
-				EndOfStmt();
-				ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes);
-					cd.StartLocation = m.GetDeclarationLocation(startPos);
-					cd.EndLocation   = constructorEndLocation;
-					cd.Body = (BlockStatement)stmt;
-					cd.Body.EndLocation   = endLocation;
-					AddChild(cd);
-
-			} else SynErr(258);
-			break;
-		}
-		case 127: {
-			Get();
-			m.Check(Modifiers.VBMethods);
-				string name = String.Empty;
-				Location startPos = t.Location;
-				MethodDeclaration methodDeclaration;List<string> handlesClause = null;
-				List<InterfaceImplementation> implementsClause = null;
-				AttributeSection returnTypeAttributeSection = null;
-
-			Identifier();
-			name = t.val;
-			TypeParameterList(templates);
-			if (la.kind == 37) {
-				Get();
-				if (StartOf(7)) {
-					FormalParameterList(p);
-				}
-				Expect(38);
-			}
-			if (la.kind == 63) {
-				Get();
-				while (la.kind == 40) {
-					AttributeSection(out returnTypeAttributeSection);
-					if (returnTypeAttributeSection != null) {
-							returnTypeAttributeSection.AttributeTarget = "return";
-							attributes.Add(returnTypeAttributeSection);
-						}
-
-				}
-				TypeName(out type);
-			}
-			if(type == null) {
-					type = new TypeReference("System.Object", true);
-				}
-
-			if (la.kind == 134 || la.kind == 136) {
-				if (la.kind == 136) {
-					ImplementsClause(out implementsClause);
-				} else {
-					HandlesClause(out handlesClause);
-				}
-			}
-			Location endLocation = t.EndLocation;
-			if (IsMustOverride(m)) {
-				EndOfStmt();
-				methodDeclaration = new MethodDeclaration {
-						Name = name, Modifier = m.Modifier, TypeReference = type,
-						Parameters = p, Attributes = attributes,
-						StartLocation = m.GetDeclarationLocation(startPos),
-						EndLocation   = endLocation,
-						HandlesClause = handlesClause,
-						Templates     = templates,
-						InterfaceImplementations = implementsClause
-					};
-					
-					AddChild(methodDeclaration);
-
-			} else if (la.kind == 1) {
-				Get();
-				methodDeclaration = new MethodDeclaration {
-						Name = name, Modifier = m.Modifier, TypeReference = type,
-						Parameters = p, Attributes = attributes,
-						StartLocation = m.GetDeclarationLocation(startPos),
-						EndLocation   = endLocation,
-						Templates     = templates,
-						HandlesClause = handlesClause,
-						InterfaceImplementations = implementsClause
-					};
-					
-					AddChild(methodDeclaration);
-
-					if (ParseMethodBodies) {
-				Block(out stmt);
-				Expect(113);
-				Expect(127);
-				} else {
-						// don't parse method body
-						lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
-					}
-					methodDeclaration.Body = (BlockStatement)stmt;
-					methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation;
-					methodDeclaration.Body.EndLocation   = t.EndLocation;
-
-				EndOfStmt();
-			} else SynErr(259);
-			break;
-		}
-		case 101: {
-			Get();
-			m.Check(Modifiers.VBExternalMethods);
-				Location startPos = t.Location;
-				CharsetModifier charsetModifer = CharsetModifier.None;
-				string library = String.Empty;
-				string alias = null;
-				string name = String.Empty;
-
-			if (StartOf(16)) {
-				Charset(out charsetModifer);
-			}
-			if (la.kind == 210) {
-				Get();
-				Identifier();
-				name = t.val;
-				Expect(149);
-				Expect(3);
-				library = t.literalValue as string;
-				if (la.kind == 59) {
-					Get();
-					Expect(3);
-					alias = t.literalValue as string;
-				}
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				EndOfStmt();
-				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
-					declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
-					declareDeclaration.EndLocation   = t.EndLocation;
-					AddChild(declareDeclaration);
-
-			} else if (la.kind == 127) {
-				Get();
-				Identifier();
-				name = t.val;
-				Expect(149);
-				Expect(3);
-				library = t.literalValue as string;
-				if (la.kind == 59) {
-					Get();
-					Expect(3);
-					alias = t.literalValue as string;
-				}
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				if (la.kind == 63) {
-					Get();
-					TypeName(out type);
-				}
-				EndOfStmt();
-				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
-					declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
-					declareDeclaration.EndLocation   = t.EndLocation;
-					AddChild(declareDeclaration);
-
-			} else SynErr(260);
-			break;
-		}
-		case 119: {
-			Get();
-			m.Check(Modifiers.VBEvents);
-				Location startPos = t.Location;
-				EventDeclaration eventDeclaration;
-				string name = String.Empty;
-				List<InterfaceImplementation> implementsClause = null;
-
-			Identifier();
-			name= t.val;
-			if (la.kind == 63) {
-				Get();
-				TypeName(out type);
-			} else if (StartOf(17)) {
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-			} else SynErr(261);
-			if (la.kind == 136) {
-				ImplementsClause(out implementsClause);
-			}
-			eventDeclaration = new EventDeclaration {
-					Name = name, TypeReference = type, Modifier = m.Modifier, 
-					Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
-					StartLocation = m.GetDeclarationLocation(startPos),
-					EndLocation = t.EndLocation
-				};
-				AddChild(eventDeclaration);
-
-			EndOfStmt();
-			break;
-		}
-		case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
-			m.Check(Modifiers.Fields);
-				FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
-
-			IdentifierForFieldDeclaration();
-			string name = t.val;
-			fd.StartLocation = m.GetDeclarationLocation(t.Location);
-			VariableDeclaratorPartAfterIdentifier(variableDeclarators, name);
-			while (la.kind == 22) {
-				Get();
-				VariableDeclarator(variableDeclarators);
-			}
-			EndOfStmt();
-			fd.EndLocation = t.EndLocation;
-				fd.Fields = variableDeclarators;
-				AddChild(fd);
-
-			break;
-		}
-		case 88: {
-			m.Check(Modifiers.Fields);
-			Get();
-			m.Add(Modifiers.Const, t.Location); 
-			FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
-				fd.StartLocation = m.GetDeclarationLocation(t.Location);
-				List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();
-
-			ConstantDeclarator(constantDeclarators);
-			while (la.kind == 22) {
-				Get();
-				ConstantDeclarator(constantDeclarators);
-			}
-			fd.Fields = constantDeclarators;
-				fd.EndLocation = t.Location;
-
-			EndOfStmt();
-			fd.EndLocation = t.EndLocation;
-				AddChild(fd);
-
-			break;
-		}
-		case 186: {
-			Get();
-			m.Check(Modifiers.VBProperties);
-				Location startPos = t.Location;
-				List<InterfaceImplementation> implementsClause = null;
-				AttributeSection returnTypeAttributeSection = null;
-				Expression initializer = null;
-
-			Identifier();
-			string propertyName = t.val;
-			if (la.kind == 37) {
-				Get();
-				if (StartOf(7)) {
-					FormalParameterList(p);
-				}
-				Expect(38);
-			}
-			if (la.kind == 63) {
-				Get();
-				while (la.kind == 40) {
-					AttributeSection(out returnTypeAttributeSection);
-					if (returnTypeAttributeSection != null) {
-							returnTypeAttributeSection.AttributeTarget = "return";
-							attributes.Add(returnTypeAttributeSection);
-						}
-
-				}
-				if (IsNewExpression()) {
-					ObjectCreateExpression(out initializer);
-					if (initializer is ObjectCreateExpression) {
-							type = ((ObjectCreateExpression)initializer).CreateType.Clone();
-						} else {
-							type = ((ArrayCreateExpression)initializer).CreateType.Clone();
-						}
-
-				} else if (StartOf(9)) {
-					TypeName(out type);
-				} else SynErr(262);
-			}
-			if (la.kind == 20) {
-				Get();
-				Expr(out initializer);
-			}
-			if (la.kind == 136) {
-				ImplementsClause(out implementsClause);
-			}
-			EndOfStmt();
-			if (IsMustOverride(m) || IsAutomaticProperty()) {
-				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
-					pDecl.StartLocation = m.GetDeclarationLocation(startPos);
-					pDecl.EndLocation   = t.Location;
-					pDecl.TypeReference = type;
-					pDecl.InterfaceImplementations = implementsClause;
-					pDecl.Parameters = p;
-					if (initializer != null)
-						pDecl.Initializer = initializer;
-					AddChild(pDecl);
-
-			} else if (StartOf(18)) {
-				PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
-					pDecl.StartLocation = m.GetDeclarationLocation(startPos);
-					pDecl.EndLocation   = t.Location;
-					pDecl.BodyStart   = t.Location;
-					pDecl.TypeReference = type;
-					pDecl.InterfaceImplementations = implementsClause;
-					pDecl.Parameters = p;
-					PropertyGetRegion getRegion;
-					PropertySetRegion setRegion;
-
-				AccessorDecls(out getRegion, out setRegion);
-				Expect(113);
-				Expect(186);
-				EndOfStmt();
-				pDecl.GetRegion = getRegion;
-					pDecl.SetRegion = setRegion;
-					pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
-					AddChild(pDecl);
-
-			} else SynErr(263);
-			break;
-		}
-		case 98: {
-			Get();
-			Location startPos = t.Location;
-			Expect(119);
-			m.Check(Modifiers.VBCustomEvents);
-				EventAddRemoveRegion eventAccessorDeclaration;
-				EventAddRegion addHandlerAccessorDeclaration = null;
-				EventRemoveRegion removeHandlerAccessorDeclaration = null;
-				EventRaiseRegion raiseEventAccessorDeclaration = null;
-				List<InterfaceImplementation> implementsClause = null;
-
-			Identifier();
-			string customEventName = t.val;
-			Expect(63);
-			TypeName(out type);
-			if (la.kind == 136) {
-				ImplementsClause(out implementsClause);
-			}
-			EndOfStmt();
-			while (StartOf(19)) {
-				EventAccessorDeclaration(out eventAccessorDeclaration);
-				if(eventAccessorDeclaration is EventAddRegion)
-					{
-						addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
-					}
-					else if(eventAccessorDeclaration is EventRemoveRegion)
-					{
-						removeHandlerAccessorDeclaration = (EventRemoveRegion)eventAccessorDeclaration;
-					}
-					else if(eventAccessorDeclaration is EventRaiseRegion)
-					{
-						raiseEventAccessorDeclaration = (EventRaiseRegion)eventAccessorDeclaration;
-					}
-
-			}
-			Expect(113);
-			Expect(119);
-			EndOfStmt();
-			if(addHandlerAccessorDeclaration == null)
-				{
-					Error("Need to provide AddHandler accessor.");
-				}
-				
-				if(removeHandlerAccessorDeclaration == null)
-				{
-					Error("Need to provide RemoveHandler accessor.");
-				}
-				
-				if(raiseEventAccessorDeclaration == null)
-				{
-					Error("Need to provide RaiseEvent accessor.");
-				}
-
-				EventDeclaration decl = new EventDeclaration {
-					TypeReference = type, Name = customEventName, Modifier = m.Modifier,
-					Attributes = attributes,
-					StartLocation = m.GetDeclarationLocation(startPos),
-					EndLocation = t.EndLocation,
-					AddRegion = addHandlerAccessorDeclaration,
-					RemoveRegion = removeHandlerAccessorDeclaration,
-					RaiseRegion = raiseEventAccessorDeclaration
-				};
-				AddChild(decl);
-
-			break;
-		}
-		case 161: case 172: case 232: {
-			ConversionType opConversionType = ConversionType.None;
-			if (la.kind == 161 || la.kind == 232) {
-				if (la.kind == 232) {
-					Get();
-					opConversionType = ConversionType.Implicit;
-				} else {
-					Get();
-					opConversionType = ConversionType.Explicit;
-				}
-			}
-			Expect(172);
-			m.Check(Modifiers.VBOperators);
-				Location startPos = t.Location;
-				TypeReference returnType = NullTypeReference.Instance;
-				TypeReference operandType = NullTypeReference.Instance;
-				OverloadableOperatorType operatorType;
-				AttributeSection section;
-				ParameterDeclarationExpression param;
-				List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
-
-			OverloadableOperator(out operatorType);
-			Expect(37);
-			FormalParameter(out param);
-			if (param != null) parameters.Add(param);
-			if (la.kind == 22) {
-				Get();
-				FormalParameter(out param);
-				if (param != null) parameters.Add(param);
-			}
-			Expect(38);
-			Location endPos = t.EndLocation;
-			if (la.kind == 63) {
-				Get();
-				while (la.kind == 40) {
-					AttributeSection(out section);
-					if (section != null) {
-						section.AttributeTarget = "return";
-						attributes.Add(section);
-					}
-				}
-				TypeName(out returnType);
-				endPos = t.EndLocation;
-			}
-			Expect(1);
-			Block(out stmt);
-			Expect(113);
-			Expect(172);
-			EndOfStmt();
-			OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
-					Modifier = m.Modifier,
-					Attributes = attributes,
-					Parameters = parameters,
-					TypeReference = returnType,
-					OverloadableOperator = operatorType,
-					ConversionType = opConversionType,
-					Body = (BlockStatement)stmt,
-					StartLocation = m.GetDeclarationLocation(startPos),
-					EndLocation = endPos
-				};
-				operatorDeclaration.Body.StartLocation = startPos;
-				operatorDeclaration.Body.EndLocation = t.Location;
-				AddChild(operatorDeclaration);
-
-			break;
-		}
-		default: SynErr(264); break;
-		}
-	}
-
-	void EnumMemberDecl(out FieldDeclaration f) {
-		Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
-		AttributeSection section = null;
-		VariableDeclaration varDecl = null;
-
-		while (la.kind == 40) {
-			AttributeSection(out section);
-			attributes.Add(section);
-		}
-		Identifier();
-		f = new FieldDeclaration(attributes);
-			varDecl = new VariableDeclaration(t.val);
-			f.Fields.Add(varDecl);
-			f.StartLocation = varDecl.StartLocation = t.Location;
-
-		if (la.kind == 20) {
-			Get();
-			Expr(out expr);
-			varDecl.Initializer = expr;
-		}
-		f.EndLocation = varDecl.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void InterfaceMemberDecl() {
-		TypeReference type =null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		List<TemplateDefinition> templates = new List<TemplateDefinition>();
-		AttributeSection section, returnTypeAttributeSection = null;
-		ModifierList mod = new ModifierList();
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		string name;
-
-		if (StartOf(20)) {
-			while (la.kind == 40) {
-				AttributeSection(out section);
-				attributes.Add(section);
-			}
-			while (StartOf(11)) {
-				MemberModifier(mod);
-			}
-			if (la.kind == 119) {
-				Get();
-				mod.Check(Modifiers.VBInterfaceEvents);
-					Location startLocation = t.Location;
-
-				Identifier();
-				name = t.val;
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				if (la.kind == 63) {
-					Get();
-					TypeName(out type);
-				}
-				EndOfStmt();
-				EventDeclaration ed = new EventDeclaration {
-						Name = name, TypeReference = type, Modifier = mod.Modifier,
-						Parameters = p, Attributes = attributes,
-						StartLocation = startLocation, EndLocation = t.EndLocation
-					};
-					AddChild(ed);
-
-			} else if (la.kind == 210) {
-				Get();
-				Location startLocation =  t.Location;
-					mod.Check(Modifiers.VBInterfaceMethods);
-
-				Identifier();
-				name = t.val;
-				TypeParameterList(templates);
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				EndOfStmt();
-				MethodDeclaration md = new MethodDeclaration {
-						Name = name, 
-						Modifier = mod.Modifier, 
-						Parameters = p,
-						Attributes = attributes,
-						TypeReference = new TypeReference("System.Void", true),
-						StartLocation = startLocation,
-						EndLocation = t.EndLocation,
-						Templates = templates
-					};
-					AddChild(md);
-
-			} else if (la.kind == 127) {
-				Get();
-				mod.Check(Modifiers.VBInterfaceMethods);
-					Location startLocation = t.Location;
-
-				Identifier();
-				name = t.val;
-				TypeParameterList(templates);
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				if (la.kind == 63) {
-					Get();
-					while (la.kind == 40) {
-						AttributeSection(out returnTypeAttributeSection);
-					}
-					TypeName(out type);
-				}
-				if(type == null) {
-						type = new TypeReference("System.Object", true);
-					}
-					MethodDeclaration md = new MethodDeclaration {
-						Name = name, Modifier = mod.Modifier, 
-						TypeReference = type, Parameters = p, Attributes = attributes
-					};
-					if (returnTypeAttributeSection != null) {
-						returnTypeAttributeSection.AttributeTarget = "return";
-						md.Attributes.Add(returnTypeAttributeSection);
-					}
-					md.StartLocation = startLocation;
-					md.EndLocation = t.EndLocation;
-					md.Templates = templates;
-					AddChild(md);
-
-				EndOfStmt();
-			} else if (la.kind == 186) {
-				Get();
-				Location startLocation = t.Location;
-					mod.Check(Modifiers.VBInterfaceProperties);
-
-				Identifier();
-				name = t.val; 
-				if (la.kind == 37) {
-					Get();
-					if (StartOf(7)) {
-						FormalParameterList(p);
-					}
-					Expect(38);
-				}
-				if (la.kind == 63) {
-					Get();
-					TypeName(out type);
-				}
-				if(type == null) {
-						type = new TypeReference("System.Object", true);
-					}
-
-				EndOfStmt();
-				PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
-					pd.Parameters = p;
-					pd.EndLocation = t.EndLocation;
-					pd.StartLocation = startLocation;
-					AddChild(pd);
-
-			} else SynErr(265);
-		} else if (StartOf(21)) {
-			NonModuleDeclaration(mod, attributes);
-		} else SynErr(266);
-	}
-
-	void Expr(out Expression expr) {
-		expr = null; Location startLocation = la.Location;
-		if (IsQueryExpression()) {
-			QueryExpr(out expr);
-		} else if (la.kind == 127 || la.kind == 210) {
-			LambdaExpr(out expr);
-		} else if (StartOf(22)) {
-			DisjunctionExpr(out expr);
-		} else SynErr(267);
-		if (expr != null) {
-				expr.StartLocation = startLocation;
-				expr.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void ImplementsClause(out List<InterfaceImplementation> baseInterfaces) {
-		baseInterfaces = new List<InterfaceImplementation>();
-		TypeReference type = null;
-		string memberName = null;
-
-		Expect(136);
-		NonArrayTypeName(out type, false);
-		if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type);
-		baseInterfaces.Add(new InterfaceImplementation(type, memberName));
-		while (la.kind == 22) {
-			Get();
-			NonArrayTypeName(out type, false);
-			if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type);
-			baseInterfaces.Add(new InterfaceImplementation(type, memberName));
-		}
-	}
-
-	void HandlesClause(out List<string> handlesClause) {
-		handlesClause = new List<string>();
-		string name;
-
-		Expect(134);
-		EventMemberSpecifier(out name);
-		if (name != null) handlesClause.Add(name);
-		while (la.kind == 22) {
-			Get();
-			EventMemberSpecifier(out name);
-			if (name != null) handlesClause.Add(name);
-		}
-	}
-
-	void Block(out Statement stmt) {
-		BlockStatement blockStmt = new BlockStatement();
-			/* in snippet parsing mode, t might be null */
-			if (t != null) blockStmt.StartLocation = t.EndLocation;
-			BlockStart(blockStmt);
-
-		while (IsEndStmtAhead() || StartOf(StatementEndOfStmt)) {
-			if (la.kind == 113) {
-				Get();
-				Token first = t;
-					AddChild(new EndStatement() {
-						StartLocation = first.Location,
-						EndLocation = first.EndLocation }
-					);
-
-				EndOfStmt();
-			} else if (StartOf(1)) {
-				Statement();
-				EndOfStmt();
-			} else SynErr(268);
-		}
-		stmt = blockStmt;
-			if (t != null) blockStmt.EndLocation = t.EndLocation;
-			BlockEnd();
-
-	}
-
-	void Charset(out CharsetModifier charsetModifier) {
-		charsetModifier = CharsetModifier.None;
-		if (la.kind == 127 || la.kind == 210) {
-		} else if (la.kind == 62) {
-			Get();
-			charsetModifier = CharsetModifier.Ansi;
-		} else if (la.kind == 66) {
-			Get();
-			charsetModifier = CharsetModifier.Auto;
-		} else if (la.kind == 223) {
-			Get();
-			charsetModifier = CharsetModifier.Unicode;
-		} else SynErr(269);
-	}
-
-	void IdentifierForFieldDeclaration() {
-		switch (la.kind) {
-		case 2: {
-			Get();
-			break;
-		}
-		case 58: {
-			Get();
-			break;
-		}
-		case 62: {
-			Get();
-			break;
-		}
-		case 64: {
-			Get();
-			break;
-		}
-		case 65: {
-			Get();
-			break;
-		}
-		case 66: {
-			Get();
-			break;
-		}
-		case 67: {
-			Get();
-			break;
-		}
-		case 70: {
-			Get();
-			break;
-		}
-		case 87: {
-			Get();
-			break;
-		}
-		case 104: {
-			Get();
-			break;
-		}
-		case 107: {
-			Get();
-			break;
-		}
-		case 116: {
-			Get();
-			break;
-		}
-		case 121: {
-			Get();
-			break;
-		}
-		case 126: {
-			Get();
-			break;
-		}
-		case 133: {
-			Get();
-			break;
-		}
-		case 139: {
-			Get();
-			break;
-		}
-		case 143: {
-			Get();
-			break;
-		}
-		case 146: {
-			Get();
-			break;
-		}
-		case 147: {
-			Get();
-			break;
-		}
-		case 170: {
-			Get();
-			break;
-		}
-		case 176: {
-			Get();
-			break;
-		}
-		case 178: {
-			Get();
-			break;
-		}
-		case 184: {
-			Get();
-			break;
-		}
-		case 203: {
-			Get();
-			break;
-		}
-		case 212: {
-			Get();
-			break;
-		}
-		case 213: {
-			Get();
-			break;
-		}
-		case 223: {
-			Get();
-			break;
-		}
-		case 224: {
-			Get();
-			break;
-		}
-		case 230: {
-			Get();
-			break;
-		}
-		default: SynErr(270); break;
-		}
-	}
-
-	void VariableDeclaratorPartAfterIdentifier(List<VariableDeclaration> fieldDeclaration, string name) {
-		Expression expr = null;
-		TypeReference type = null;
-		ArrayList rank = null;
-		List<Expression> dimension = null;
-		Location startLocation = t.Location;
-
-		if (IsSize() && !IsDims()) {
-			ArrayInitializationModifier(out dimension);
-		}
-		if (IsDims()) {
-			ArrayNameModifier(out rank);
-		}
-		if (IsObjectCreation()) {
-			Expect(63);
-			ObjectCreateExpression(out expr);
-			if (expr is ObjectCreateExpression) {
-					type = ((ObjectCreateExpression)expr).CreateType.Clone();
-				} else {
-					type = ((ArrayCreateExpression)expr).CreateType.Clone();
-				}
-
-		} else if (StartOf(23)) {
-			if (la.kind == 63) {
-				Get();
-				TypeName(out type);
-				if (type != null) {
-					for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
-						VariableDeclaration vd = fieldDeclaration[i];
-						if (vd.TypeReference.Type.Length > 0) break;
-						TypeReference newType = type.Clone();
-						newType.RankSpecifier = vd.TypeReference.RankSpecifier;
-						vd.TypeReference = newType;
-					}
-				}
-
-			}
-			if (type == null && (dimension != null || rank != null)) {
-					type = new TypeReference("");
-				}
-				if (dimension != null) {
-					if(type.RankSpecifier != null) {
-						Error("array rank only allowed one time");
-					} else {
-						if (rank == null) {
-							type.RankSpecifier = new int[] { dimension.Count - 1 };
-						} else {
-							rank.Insert(0, dimension.Count - 1);
-							type.RankSpecifier = (int[])rank.ToArray(typeof(int));
-						}
-						expr = new ArrayCreateExpression(type.Clone(), dimension);
-					}
-				} else if (rank != null) {
-					if(type.RankSpecifier != null) {
-						Error("array rank only allowed one time");
-					} else {
-						type.RankSpecifier = (int[])rank.ToArray(typeof(int));
-					}
-				}
-
-			if (la.kind == 20) {
-				Get();
-				Expr(out expr);
-			}
-		} else SynErr(271);
-		VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
-			varDecl.StartLocation = startLocation;
-			varDecl.EndLocation = t.Location;
-			fieldDeclaration.Add(varDecl);
-
-	}
-
-	void VariableDeclarator(List<VariableDeclaration> fieldDeclaration) {
-		Identifier();
-		string name = t.val;
-		VariableDeclaratorPartAfterIdentifier(fieldDeclaration, name);
-	}
-
-	void ConstantDeclarator(List<VariableDeclaration> constantDeclaration) {
-		Expression expr = null;
-		TypeReference type = null;
-		string name = String.Empty;
-		Location location;
-
-		Identifier();
-		name = t.val; location = t.Location;
-		if (la.kind == 63) {
-			Get();
-			TypeName(out type);
-		}
-		Expect(20);
-		Expr(out expr);
-		VariableDeclaration f = new VariableDeclaration(name, expr);
-			f.TypeReference = type;
-			f.StartLocation = location;
-			constantDeclaration.Add(f);
-
-	}
-
-	void ObjectCreateExpression(out Expression oce) {
-		TypeReference type = null;
-		CollectionInitializerExpression initializer = null;
-		List<Expression> arguments = null;
-		ArrayList dimensions = null;
-		oce = null;
-		Location startLocation = la.Location;
-		bool canBeNormal; bool canBeReDim;
-
-		Expect(162);
-		if (StartOf(9)) {
-			NonArrayTypeName(out type, false);
-			if (la.kind == 37) {
-				Get();
-				NormalOrReDimArgumentList(out arguments, out canBeNormal, out canBeReDim);
-				Expect(38);
-				if (la.kind == 35 || (la.kind == Tokens.OpenParenthesis)) {
-					if (la.kind == Tokens.OpenParenthesis) {
-						ArrayTypeModifiers(out dimensions);
-						CollectionInitializer(out initializer);
-					} else {
-						CollectionInitializer(out initializer);
-					}
-				}
-				if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression();
-			}
-		}
-		if (initializer == null) {
-				oce = new ObjectCreateExpression(type, arguments);
-			} else {
-				if (dimensions == null) dimensions = new ArrayList();
-				dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0));
-				type.RankSpecifier = (int[])dimensions.ToArray(typeof(int));
-				ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer);
-				ace.Arguments = arguments;
-				oce = ace;
-			}
-
-		if (la.kind == 126 || la.kind == 233) {
-			if (la.kind == 233) {
-				MemberInitializerExpression memberInitializer = null;
-					Expression anonymousMember = null;
-
-				Get();
-				CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
-					memberInitializers.StartLocation = la.Location;
-
-				Expect(35);
-				if (la.kind == 26 || la.kind == 147) {
-					MemberInitializer(out memberInitializer);
-					memberInitializers.CreateExpressions.Add(memberInitializer);
-				} else if (StartOf(24)) {
-					Expr(out anonymousMember);
-					memberInitializers.CreateExpressions.Add(anonymousMember);
-				} else SynErr(272);
-				while (la.kind == 22) {
-					Get();
-					if (la.kind == 26 || la.kind == 147) {
-						MemberInitializer(out memberInitializer);
-						memberInitializers.CreateExpressions.Add(memberInitializer);
-					} else if (StartOf(24)) {
-						Expr(out anonymousMember);
-						memberInitializers.CreateExpressions.Add(anonymousMember);
-					} else SynErr(273);
-				}
-				Expect(36);
-				memberInitializers.EndLocation = t.Location;
-					if(oce is ObjectCreateExpression)
-					{
-						((ObjectCreateExpression)oce).ObjectInitializer = memberInitializers;
-					}
-
-			} else {
-				Get();
-				CollectionInitializer(out initializer);
-				if(oce is ObjectCreateExpression)
-						((ObjectCreateExpression)oce).ObjectInitializer = initializer;
-
-			}
-		}
-		if (oce != null) {
-				oce.StartLocation = startLocation;
-				oce.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void AccessorDecls(out PropertyGetRegion getBlock, out PropertySetRegion setBlock) {
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		AttributeSection section;
-		getBlock = null;
-		setBlock = null; 
-
-		while (la.kind == 40) {
-			AttributeSection(out section);
-			attributes.Add(section);
-		}
-		if (StartOf(25)) {
-			GetAccessorDecl(out getBlock, attributes);
-			if (StartOf(26)) {
-				attributes = new List<AttributeSection>();
-				while (la.kind == 40) {
-					AttributeSection(out section);
-					attributes.Add(section);
-				}
-				SetAccessorDecl(out setBlock, attributes);
-			}
-		} else if (StartOf(27)) {
-			SetAccessorDecl(out setBlock, attributes);
-			if (StartOf(28)) {
-				attributes = new List<AttributeSection>();
-				while (la.kind == 40) {
-					AttributeSection(out section);
-					attributes.Add(section);
-				}
-				GetAccessorDecl(out getBlock, attributes);
-			}
-		} else SynErr(274);
-	}
-
-	void EventAccessorDeclaration(out EventAddRemoveRegion eventAccessorDeclaration) {
-		Statement stmt = null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		AttributeSection section;
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		eventAccessorDeclaration = null;
-
-		while (la.kind == 40) {
-			AttributeSection(out section);
-			attributes.Add(section);
-		}
-		if (la.kind == 56) {
-			Get();
-			if (la.kind == 37) {
-				Get();
-				if (StartOf(7)) {
-					FormalParameterList(p);
-				}
-				Expect(38);
-			}
-			Expect(1);
-			Block(out stmt);
-			Expect(113);
-			Expect(56);
-			EndOfStmt();
-			eventAccessorDeclaration = new EventAddRegion(attributes);
-				eventAccessorDeclaration.Block = (BlockStatement)stmt;
-				eventAccessorDeclaration.Parameters = p;
-
-		} else if (la.kind == 193) {
-			Get();
-			if (la.kind == 37) {
-				Get();
-				if (StartOf(7)) {
-					FormalParameterList(p);
-				}
-				Expect(38);
-			}
-			Expect(1);
-			Block(out stmt);
-			Expect(113);
-			Expect(193);
-			EndOfStmt();
-			eventAccessorDeclaration = new EventRemoveRegion(attributes);
-				eventAccessorDeclaration.Block = (BlockStatement)stmt;
-				eventAccessorDeclaration.Parameters = p;
-
-		} else if (la.kind == 189) {
-			Get();
-			if (la.kind == 37) {
-				Get();
-				if (StartOf(7)) {
-					FormalParameterList(p);
-				}
-				Expect(38);
-			}
-			Expect(1);
-			Block(out stmt);
-			Expect(113);
-			Expect(189);
-			EndOfStmt();
-			eventAccessorDeclaration = new EventRaiseRegion(attributes);
-				eventAccessorDeclaration.Block = (BlockStatement)stmt;
-				eventAccessorDeclaration.Parameters = p;
-
-		} else SynErr(275);
-	}
-
-	void OverloadableOperator(out OverloadableOperatorType operatorType) {
-		operatorType = OverloadableOperatorType.None;
-		switch (la.kind) {
-		case 31: {
-			Get();
-			operatorType = OverloadableOperatorType.Add;
-			break;
-		}
-		case 30: {
-			Get();
-			operatorType = OverloadableOperatorType.Subtract;
-			break;
-		}
-		case 34: {
-			Get();
-			operatorType = OverloadableOperatorType.Multiply;
-			break;
-		}
-		case 24: {
-			Get();
-			operatorType = OverloadableOperatorType.Divide;
-			break;
-		}
-		case 25: {
-			Get();
-			operatorType = OverloadableOperatorType.DivideInteger;
-			break;
-		}
-		case 23: {
-			Get();
-			operatorType = OverloadableOperatorType.Concat;
-			break;
-		}
-		case 150: {
-			Get();
-			operatorType = OverloadableOperatorType.Like;
-			break;
-		}
-		case 154: {
-			Get();
-			operatorType = OverloadableOperatorType.Modulus;
-			break;
-		}
-		case 60: {
-			Get();
-			operatorType = OverloadableOperatorType.BitwiseAnd;
-			break;
-		}
-		case 175: {
-			Get();
-			operatorType = OverloadableOperatorType.BitwiseOr;
-			break;
-		}
-		case 236: {
-			Get();
-			operatorType = OverloadableOperatorType.ExclusiveOr;
-			break;
-		}
-		case 32: {
-			Get();
-			operatorType = OverloadableOperatorType.Power;
-			break;
-		}
-		case 44: {
-			Get();
-			operatorType = OverloadableOperatorType.ShiftLeft;
-			break;
-		}
-		case 45: {
-			Get();
-			operatorType = OverloadableOperatorType.ShiftRight;
-			break;
-		}
-		case 20: {
-			Get();
-			operatorType = OverloadableOperatorType.Equality;
-			break;
-		}
-		case 41: {
-			Get();
-			operatorType = OverloadableOperatorType.InEquality;
-			break;
-		}
-		case 40: {
-			Get();
-			operatorType = OverloadableOperatorType.LessThan;
-			break;
-		}
-		case 43: {
-			Get();
-			operatorType = OverloadableOperatorType.LessThanOrEqual;
-			break;
-		}
-		case 39: {
-			Get();
-			operatorType = OverloadableOperatorType.GreaterThan;
-			break;
-		}
-		case 42: {
-			Get();
-			operatorType = OverloadableOperatorType.GreaterThanOrEqual;
-			break;
-		}
-		case 94: {
-			Get();
-			operatorType = OverloadableOperatorType.CType;
-			break;
-		}
-		case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
-			Identifier();
-			string opName = t.val; 
-				if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
-					operatorType = OverloadableOperatorType.IsTrue;
-				} else if (string.Equals(opName, "isfalse", StringComparison.InvariantCultureIgnoreCase)) {
-					operatorType = OverloadableOperatorType.IsFalse;
-				} else {
-					Error("Invalid operator. Possible operators are '+', '-', 'Not', 'IsTrue', 'IsFalse'.");
-				}
-
-			break;
-		}
-		default: SynErr(276); break;
-		}
-	}
-
-	void FormalParameter(out ParameterDeclarationExpression p) {
-		AttributeSection section;
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		TypeReference type = null;
-		ParamModifierList mod = new ParamModifierList(this);
-		Expression expr = null;
-		p = null;
-		ArrayList arrayModifiers = null;
-		Location startLocation = la.Location;
-
-		while (la.kind == 40) {
-			AttributeSection(out section);
-			attributes.Add(section);
-		}
-		while (StartOf(29)) {
-			ParameterModifier(mod);
-		}
-		Identifier();
-		string parameterName = t.val;
-		if (IsDims()) {
-			ArrayTypeModifiers(out arrayModifiers);
-		}
-		if (la.kind == 63) {
-			Get();
-			TypeName(out type);
-		}
-		if(type != null) {
-				if (arrayModifiers != null) {
-					if (type.RankSpecifier != null) {
-						Error("array rank only allowed one time");
-					} else {
-						type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int));
-					}
-				}
-			}
-
-		if (la.kind == 20) {
-			Get();
-			Expr(out expr);
-		}
-		mod.Check();
-			p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
-			p.Attributes = attributes;
-			p.StartLocation = startLocation;
-			p.EndLocation = t.EndLocation;
-
-	}
-
-	void GetAccessorDecl(out PropertyGetRegion getBlock, List<AttributeSection> attributes) {
-		Statement stmt = null; Modifiers m;
-		PropertyAccessorAccessModifier(out m);
-		Expect(128);
-		Location startLocation = t.Location;
-		Expect(1);
-		Block(out stmt);
-		getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes);
-		Expect(113);
-		Expect(128);
-		getBlock.Modifier = m;
-		getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void SetAccessorDecl(out PropertySetRegion setBlock, List<AttributeSection> attributes) {
-		Statement stmt = null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		Modifiers m;
-
-		PropertyAccessorAccessModifier(out m);
-		Expect(198);
-		Location startLocation = t.Location;
-		if (la.kind == 37) {
-			Get();
-			if (StartOf(7)) {
-				FormalParameterList(p);
-			}
-			Expect(38);
-		}
-		Expect(1);
-		Block(out stmt);
-		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
-			setBlock.Modifier = m;
-			setBlock.Parameters = p;
-
-		Expect(113);
-		Expect(198);
-		setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation;
-		EndOfStmt();
-	}
-
-	void PropertyAccessorAccessModifier(out Modifiers m) {
-		m = Modifiers.None;
-		while (StartOf(30)) {
-			if (la.kind == 188) {
-				Get();
-				m |= Modifiers.Public;
-			} else if (la.kind == 187) {
-				Get();
-				m |= Modifiers.Protected;
-			} else if (la.kind == 125) {
-				Get();
-				m |= Modifiers.Internal;
-			} else {
-				Get();
-				m |= Modifiers.Private;
-			}
-		}
-	}
-
-	void ArrayInitializationModifier(out List<Expression> arrayModifiers) {
-		arrayModifiers = null;
-
-		Expect(37);
-		InitializationRankList(out arrayModifiers);
-		Expect(38);
-	}
-
-	void ArrayNameModifier(out ArrayList arrayModifiers) {
-		arrayModifiers = null;
-
-		ArrayTypeModifiers(out arrayModifiers);
-	}
-
-	void InitializationRankList(out List<Expression> rank) {
-		rank = new List<Expression>();
-		Expression expr = null;
-
-		Expr(out expr);
-		if (la.kind == 216) {
-			Get();
-			EnsureIsZero(expr);
-			Expr(out expr);
-		}
-		if (expr != null) { rank.Add(expr); }
-		while (la.kind == 22) {
-			Get();
-			Expr(out expr);
-			if (la.kind == 216) {
-				Get();
-				EnsureIsZero(expr);
-				Expr(out expr);
-			}
-			if (expr != null) { rank.Add(expr); }
-		}
-	}
-
-	void CollectionInitializer(out CollectionInitializerExpression outExpr) {
-		Expression expr = null;
-		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
-		Location startLocation = la.Location;
-
-		Expect(35);
-		if (StartOf(24)) {
-			Expr(out expr);
-			if (expr != null) { initializer.CreateExpressions.Add(expr); }
-
-			while (NotFinalComma()) {
-				Expect(22);
-				Expr(out expr);
-				if (expr != null) { initializer.CreateExpressions.Add(expr); }
-			}
-		}
-		Expect(36);
-		outExpr = initializer;
-			outExpr.StartLocation = startLocation;
-			outExpr.EndLocation = t.EndLocation;
-
-	}
-
-	void EventMemberSpecifier(out string name) {
-		string eventName;
-		if (StartOf(5)) {
-			Identifier();
-		} else if (la.kind == 158) {
-			Get();
-		} else if (la.kind == 153) {
-			Get();
-		} else SynErr(277);
-		name = t.val;
-		Expect(26);
-		IdentifierOrKeyword(out eventName);
-		name = name + "." + eventName;
-	}
-
-	void IdentifierOrKeyword(out string name) {
-		Get();
-		name = t.val; 
-	}
-
-	void QueryExpr(out Expression expr) {
-		QueryExpression qexpr = new QueryExpression();
-		qexpr.StartLocation = la.Location;
-		expr = qexpr;
-
-		FromOrAggregateQueryOperator(qexpr.Clauses);
-		while (StartOf(31)) {
-			QueryOperator(qexpr.Clauses);
-		}
-		qexpr.EndLocation = t.EndLocation;
-
-	}
-
-	void LambdaExpr(out Expression expr) {
-		LambdaExpression lambda = null;
-
-		if (la.kind == 210) {
-			SubLambdaExpression(out lambda);
-		} else if (la.kind == 127) {
-			FunctionLambdaExpression(out lambda);
-		} else SynErr(278);
-		expr = lambda;
-	}
-
-	void DisjunctionExpr(out Expression outExpr) {
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-
-		ConjunctionExpr(out outExpr);
-		while (la.kind == 175 || la.kind == 177 || la.kind == 236) {
-			if (la.kind == 175) {
-				Get();
-				op = BinaryOperatorType.BitwiseOr;
-			} else if (la.kind == 177) {
-				Get();
-				op = BinaryOperatorType.LogicalOr;
-			} else {
-				Get();
-				op = BinaryOperatorType.ExclusiveOr;
-			}
-			ConjunctionExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void AssignmentOperator(out AssignmentOperatorType op) {
-		op = AssignmentOperatorType.None;
-		switch (la.kind) {
-		case 20: {
-			Get();
-			op = AssignmentOperatorType.Assign;
-			break;
-		}
-		case 54: {
-			Get();
-			op = AssignmentOperatorType.ConcatString;
-			break;
-		}
-		case 46: {
-			Get();
-			op = AssignmentOperatorType.Add;
-			break;
-		}
-		case 48: {
-			Get();
-			op = AssignmentOperatorType.Subtract;
-			break;
-		}
-		case 49: {
-			Get();
-			op = AssignmentOperatorType.Multiply;
-			break;
-		}
-		case 50: {
-			Get();
-			op = AssignmentOperatorType.Divide;
-			break;
-		}
-		case 51: {
-			Get();
-			op = AssignmentOperatorType.DivideInteger;
-			break;
-		}
-		case 47: {
-			Get();
-			op = AssignmentOperatorType.Power;
-			break;
-		}
-		case 52: {
-			Get();
-			op = AssignmentOperatorType.ShiftLeft;
-			break;
-		}
-		case 53: {
-			Get();
-			op = AssignmentOperatorType.ShiftRight;
-			break;
-		}
-		default: SynErr(279); break;
-		}
-	}
-
-	void SimpleExpr(out Expression pexpr) {
-		string name; Location startLocation = la.Location;
-		SimpleNonInvocationExpression(out pexpr);
-		while (StartOf(32)) {
-			if (la.kind == 26) {
-				Get();
-				if (la.kind == 10) {
-					Get();
-					IdentifierOrKeyword(out name);
-					Expect(11);
-					pexpr = new XmlMemberAccessExpression(pexpr, XmlAxisType.Element, name, true);
-				} else if (StartOf(33)) {
-					IdentifierOrKeyword(out name);
-					pexpr = new MemberReferenceExpression(pexpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
-				} else SynErr(280);
-				if (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
-					Expect(37);
-					Expect(169);
-					TypeArgumentList(((MemberReferenceExpression)pexpr).TypeArguments);
-					Expect(38);
-				}
-			} else if (la.kind == 29) {
-				Get();
-				IdentifierOrKeyword(out name);
-				pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation });
-			} else if (la.kind == 27 || la.kind == 28) {
-				XmlAxisType type = XmlAxisType.Attribute; bool isXmlName = false;
-				if (la.kind == 28) {
-					Get();
-				} else {
-					Get();
-					type = XmlAxisType.Descendents;
-				}
-				if (la.kind == 10) {
-					Get();
-					isXmlName = true;
-				}
-				IdentifierOrKeyword(out name);
-				if (la.kind == 11) {
-					Get();
-				}
-				pexpr = new XmlMemberAccessExpression(pexpr, type, name, isXmlName);
-			} else {
-				InvocationExpression(ref pexpr);
-			}
-		}
-		if (pexpr != null) {
-				pexpr.StartLocation = startLocation;
-				pexpr.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void SimpleNonInvocationExpression(out Expression pexpr) {
-		Expression expr;
-		CollectionInitializerExpression cie;
-		TypeReference type = null;
-		string name = String.Empty;
-		Location startLocation = la.Location;
-		pexpr = null;
-
-		if (StartOf(34)) {
-			switch (la.kind) {
-			case 3: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 4: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 7: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 6: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 5: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 9: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 8: {
-				Get();
-				pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat }; 
-				break;
-			}
-			case 217: {
-				Get();
-				pexpr = new PrimitiveExpression(true, "true"); 
-				break;
-			}
-			case 122: {
-				Get();
-				pexpr = new PrimitiveExpression(false, "false");
-				break;
-			}
-			case 165: {
-				Get();
-				pexpr = new PrimitiveExpression(null, "null"); 
-				break;
-			}
-			case 37: {
-				Get();
-				Expr(out expr);
-				Expect(38);
-				pexpr = new ParenthesizedExpression(expr);
-				break;
-			}
-			case 2: case 58: case 62: case 64: case 65: case 66: case 67: case 70: case 87: case 98: case 104: case 107: case 116: case 121: case 126: case 133: case 139: case 143: case 146: case 147: case 170: case 176: case 178: case 184: case 203: case 212: case 213: case 223: case 224: case 230: {
-				Identifier();
-				pexpr = new IdentifierExpression(t.val);
-					pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
-
-				if (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
-					Expect(37);
-					Expect(169);
-					TypeArgumentList(((IdentifierExpression)pexpr).TypeArguments);
-					Expect(38);
-				}
-				break;
-			}
-			case 68: case 71: case 82: case 99: case 100: case 109: case 141: case 151: case 168: case 196: case 201: case 202: case 208: case 221: case 222: case 225: {
-				string val = String.Empty;
-				if (StartOf(13)) {
-					PrimitiveTypeName(out val);
-				} else {
-					Get();
-					val = "System.Object";
-				}
-				pexpr = new TypeReferenceExpression(new TypeReference(val, true));
-				break;
-			}
-			case 153: {
-				Get();
-				pexpr = new ThisReferenceExpression();
-				break;
-			}
-			case 158: case 159: {
-				Expression retExpr = null;
-				if (la.kind == 158) {
-					Get();
-					retExpr = new BaseReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation };
-				} else {
-					Get();
-					retExpr = new ClassReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation };
-				}
-				Expect(26);
-				IdentifierOrKeyword(out name);
-				pexpr = new MemberReferenceExpression(retExpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
-				break;
-			}
-			case 130: {
-				Get();
-				Expect(26);
-				Identifier();
-				type = new TypeReference(t.val ?? "");
-				type.IsGlobal = true;
-				pexpr = new TypeReferenceExpression(type);
-				break;
-			}
-			case 162: {
-				ObjectCreateExpression(out expr);
-				pexpr = expr;
-				break;
-			}
-			case 35: {
-				CollectionInitializer(out cie);
-				pexpr = cie;
-				break;
-			}
-			case 94: case 106: case 219: {
-				CastType castType = CastType.Cast;
-				if (la.kind == 106) {
-					Get();
-				} else if (la.kind == 94) {
-					Get();
-					castType = CastType.Conversion;
-				} else {
-					Get();
-					castType = CastType.TryCast;
-				}
-				Expect(37);
-				Expr(out expr);
-				Expect(22);
-				TypeName(out type);
-				Expect(38);
-				pexpr = new CastExpression(type, expr, castType);
-				break;
-			}
-			case 76: case 77: case 78: case 79: case 80: case 81: case 83: case 85: case 86: case 90: case 91: case 92: case 93: case 95: case 96: case 97: {
-				CastTarget(out type);
-				Expect(37);
-				Expr(out expr);
-				Expect(38);
-				pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion);
-				break;
-			}
-			case 57: {
-				Get();
-				SimpleExpr(out expr);
-				pexpr = new AddressOfExpression(expr);
-				break;
-			}
-			case 129: {
-				Get();
-				Expect(37);
-				GetTypeTypeName(out type);
-				Expect(38);
-				pexpr = new TypeOfExpression(type);
-				break;
-			}
-			case 220: {
-				Get();
-				SimpleExpr(out expr);
-				Expect(144);
-				TypeName(out type);
-				pexpr = new TypeOfIsExpression(expr, type);
-				break;
-			}
-			case 135: {
-				ConditionalExpression(out pexpr);
-				break;
-			}
-			case 10: case 16: case 17: case 18: case 19: {
-				XmlLiteralExpression(out pexpr);
-				break;
-			}
-			}
-		} else if (StartOf(35)) {
-			if (la.kind == 26) {
-				Get();
-				if (la.kind == 10) {
-					Get();
-					IdentifierOrKeyword(out name);
-					Expect(11);
-					pexpr = new XmlMemberAccessExpression(null, XmlAxisType.Element, name, true) { StartLocation = startLocation, EndLocation = t.EndLocation };
-				} else if (StartOf(33)) {
-					IdentifierOrKeyword(out name);
-					pexpr = new MemberReferenceExpression(null, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
-				} else SynErr(281);
-			} else if (la.kind == 29) {
-				Get();
-				IdentifierOrKeyword(out name);
-				pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation });
-			} else {
-				XmlAxisType axisType = XmlAxisType.Element; bool isXmlIdentifier = false;
-				if (la.kind == 27) {
-					Get();
-					axisType = XmlAxisType.Descendents;
-				} else {
-					Get();
-					axisType = XmlAxisType.Attribute;
-				}
-				if (la.kind == 10) {
-					Get();
-					isXmlIdentifier = true;
-				}
-				IdentifierOrKeyword(out name);
-				if (la.kind == 11) {
-					Get();
-				}
-				pexpr = new XmlMemberAccessExpression(null, axisType, name, isXmlIdentifier);
-			}
-		} else SynErr(282);
-		if (pexpr != null) {
-				pexpr.StartLocation = startLocation;
-				pexpr.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void TypeArgumentList(List<TypeReference> typeArguments) {
-		TypeReference typeref;
-
-		TypeName(out typeref);
-		if (typeref != null) typeArguments.Add(typeref);
-		while (la.kind == 22) {
-			Get();
-			TypeName(out typeref);
-			if (typeref != null) typeArguments.Add(typeref);
-		}
-	}
-
-	void InvocationExpression(ref Expression pexpr) {
-		List<Expression> parameters = null;
-		Expect(37);
-		Location start = t.Location;
-		ArgumentList(out parameters);
-		Expect(38);
-		pexpr = new InvocationExpression(pexpr, parameters);
-
-		pexpr.StartLocation = start; pexpr.EndLocation = t.Location;
-	}
-
-	void PrimitiveTypeName(out string type) {
-		type = String.Empty;
-		switch (la.kind) {
-		case 68: {
-			Get();
-			type = "System.Boolean";
-			break;
-		}
-		case 99: {
-			Get();
-			type = "System.DateTime";
-			break;
-		}
-		case 82: {
-			Get();
-			type = "System.Char";
-			break;
-		}
-		case 208: {
-			Get();
-			type = "System.String";
-			break;
-		}
-		case 100: {
-			Get();
-			type = "System.Decimal";
-			break;
-		}
-		case 71: {
-			Get();
-			type = "System.Byte";
-			break;
-		}
-		case 201: {
-			Get();
-			type = "System.Int16";
-			break;
-		}
-		case 141: {
-			Get();
-			type = "System.Int32";
-			break;
-		}
-		case 151: {
-			Get();
-			type = "System.Int64";
-			break;
-		}
-		case 202: {
-			Get();
-			type = "System.Single";
-			break;
-		}
-		case 109: {
-			Get();
-			type = "System.Double";
-			break;
-		}
-		case 221: {
-			Get();
-			type = "System.UInt32";
-			break;
-		}
-		case 222: {
-			Get();
-			type = "System.UInt64";
-			break;
-		}
-		case 225: {
-			Get();
-			type = "System.UInt16";
-			break;
-		}
-		case 196: {
-			Get();
-			type = "System.SByte";
-			break;
-		}
-		default: SynErr(283); break;
-		}
-	}
-
-	void CastTarget(out TypeReference type) {
-		type = null;
-
-		switch (la.kind) {
-		case 76: {
-			Get();
-			type = new TypeReference("System.Boolean", true);
-			break;
-		}
-		case 77: {
-			Get();
-			type = new TypeReference("System.Byte", true);
-			break;
-		}
-		case 90: {
-			Get();
-			type = new TypeReference("System.SByte", true);
-			break;
-		}
-		case 78: {
-			Get();
-			type = new TypeReference("System.Char", true);
-			break;
-		}
-		case 79: {
-			Get();
-			type = new TypeReference("System.DateTime", true);
-			break;
-		}
-		case 81: {
-			Get();
-			type = new TypeReference("System.Decimal", true);
-			break;
-		}
-		case 80: {
-			Get();
-			type = new TypeReference("System.Double", true);
-			break;
-		}
-		case 91: {
-			Get();
-			type = new TypeReference("System.Int16", true);
-			break;
-		}
-		case 83: {
-			Get();
-			type = new TypeReference("System.Int32", true);
-			break;
-		}
-		case 85: {
-			Get();
-			type = new TypeReference("System.Int64", true);
-			break;
-		}
-		case 97: {
-			Get();
-			type = new TypeReference("System.UInt16", true);
-			break;
-		}
-		case 95: {
-			Get();
-			type = new TypeReference("System.UInt32", true);
-			break;
-		}
-		case 96: {
-			Get();
-			type = new TypeReference("System.UInt64", true);
-			break;
-		}
-		case 86: {
-			Get();
-			type = new TypeReference("System.Object", true);
-			break;
-		}
-		case 92: {
-			Get();
-			type = new TypeReference("System.Single", true);
-			break;
-		}
-		case 93: {
-			Get();
-			type = new TypeReference("System.String", true);
-			break;
-		}
-		default: SynErr(284); break;
-		}
-	}
-
-	void GetTypeTypeName(out TypeReference typeref) {
-		ArrayList rank = null;
-		NonArrayTypeName(out typeref, true);
-		ArrayTypeModifiers(out rank);
-		if (rank != null && typeref != null) {
-				typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
-			}
-
-	}
-
-	void ConditionalExpression(out Expression expr) {
-		ConditionalExpression conditionalExpression = new ConditionalExpression();
-		BinaryOperatorExpression binaryOperatorExpression = new BinaryOperatorExpression();
-		conditionalExpression.StartLocation = binaryOperatorExpression.StartLocation = la.Location;
-
-		Expression condition = null;
-		Expression trueExpr = null;
-		Expression falseExpr = null;
-
-		Expect(135);
-		Expect(37);
-		Expr(out condition);
-		Expect(22);
-		Expr(out trueExpr);
-		if (la.kind == 22) {
-			Get();
-			Expr(out falseExpr);
-		}
-		Expect(38);
-		if(falseExpr != null)
-			{
-				conditionalExpression.Condition = condition;
-				conditionalExpression.TrueExpression = trueExpr;
-				conditionalExpression.FalseExpression = falseExpr;
-				conditionalExpression.EndLocation = t.EndLocation;
-				
-				expr = conditionalExpression;
-			}
-			else
-			{
-				binaryOperatorExpression.Left = condition;
-				binaryOperatorExpression.Right = trueExpr;
-				binaryOperatorExpression.Op = BinaryOperatorType.NullCoalescing;
-				binaryOperatorExpression.EndLocation = t.EndLocation;
-				
-				expr = binaryOperatorExpression;
-			}
-
-	}
-
-	void XmlLiteralExpression(out Expression pexpr) {
-		List<XmlExpression> exprs = new List<XmlExpression>();
-		XmlExpression currentExpression = null;
-
-		if (StartOf(36)) {
-			XmlContentExpression(exprs);
-			while (StartOf(36)) {
-				XmlContentExpression(exprs);
-			}
-			if (la.kind == 10) {
-				XmlElement(out currentExpression);
-				exprs.Add(currentExpression);
-				while (StartOf(36)) {
-					XmlContentExpression(exprs);
-				}
-			}
-		} else if (la.kind == 10) {
-			XmlElement(out currentExpression);
-			exprs.Add(currentExpression);
-			while (StartOf(36)) {
-				XmlContentExpression(exprs);
-			}
-		} else SynErr(285);
-		if (exprs.Count > 1) {
-				pexpr = new XmlDocumentExpression() { Expressions = exprs };
-			} else {
-				pexpr = exprs[0];
-			}
-
-	}
-
-	void XmlContentExpression(List<XmlExpression> exprs) {
-		XmlContentExpression expr = null;
-		if (la.kind == 16) {
-			Get();
-			expr = new XmlContentExpression(t.val, XmlContentType.Text);
-		} else if (la.kind == 18) {
-			Get();
-			expr = new XmlContentExpression(t.val, XmlContentType.CData);
-		} else if (la.kind == 17) {
-			Get();
-			expr = new XmlContentExpression(t.val, XmlContentType.Comment);
-		} else if (la.kind == 19) {
-			Get();
-			expr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction);
-		} else SynErr(286);
-		expr.StartLocation = t.Location;
-			expr.EndLocation = t.EndLocation;
-			exprs.Add(expr);
-
-	}
-
-	void XmlElement(out XmlExpression expr) {
-		XmlElementExpression el = new XmlElementExpression();
-		Expect(10);
-		el.StartLocation = t.Location;
-		if (la.kind == 12) {
-			Get();
-			Expression innerExpression;
-			Expr(out innerExpression);
-			Expect(13);
-			el.NameExpression = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression };
-		} else if (StartOf(5)) {
-			Identifier();
-			el.XmlName = t.val;
-		} else SynErr(287);
-		while (StartOf(37)) {
-			XmlAttribute(el.Attributes);
-		}
-		if (la.kind == 14) {
-			Get();
-			el.EndLocation = t.EndLocation;
-		} else if (la.kind == 11) {
-			Get();
-			while (StartOf(38)) {
-				XmlExpression child;
-				XmlNestedContent(out child);
-				el.Children.Add(child);
-			}
-			Expect(15);
-			while (StartOf(39)) {
-				Get();
-			}
-			Expect(11);
-			el.EndLocation = t.EndLocation;
-		} else SynErr(288);
-		expr = el;
-	}
-
-	void XmlNestedContent(out XmlExpression expr) {
-		XmlExpression tmpExpr = null; Location start = la.Location;
-		switch (la.kind) {
-		case 16: {
-			Get();
-			tmpExpr = new XmlContentExpression(t.val, XmlContentType.Text);
-			break;
-		}
-		case 18: {
-			Get();
-			tmpExpr = new XmlContentExpression(t.val, XmlContentType.CData);
-			break;
-		}
-		case 17: {
-			Get();
-			tmpExpr = new XmlContentExpression(t.val, XmlContentType.Comment);
-			break;
-		}
-		case 19: {
-			Get();
-			tmpExpr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction);
-			break;
-		}
-		case 12: {
-			Get();
-			Expression innerExpression;
-			Expr(out innerExpression);
-			Expect(13);
-			tmpExpr = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression };
-			break;
-		}
-		case 10: {
-			XmlElement(out tmpExpr);
-			break;
-		}
-		default: SynErr(289); break;
-		}
-		if (tmpExpr.StartLocation.IsEmpty)
-				tmpExpr.StartLocation = start;
-			if (tmpExpr.EndLocation.IsEmpty)
-				tmpExpr.EndLocation = t.EndLocation;
-			expr = tmpExpr;
-
-	}
-
-	void XmlAttribute(List<XmlExpression> attrs) {
-		Location start = la.Location;
-		if (StartOf(5)) {
-			Identifier();
-			string name = t.val;
-			Expect(20);
-			string literalValue = null; Expression expressionValue = null; bool useDoubleQuotes = false;
-			if (la.kind == 3) {
-				Get();
-				literalValue = t.literalValue.ToString(); useDoubleQuotes = t.val[0] == '"';
-			} else if (la.kind == 12) {
-				Get();
-				Expr(out expressionValue);
-				Expect(13);
-			} else SynErr(290);
-			attrs.Add(new XmlAttributeExpression() { Name = name, ExpressionValue = expressionValue, LiteralValue = literalValue, UseDoubleQuotes = useDoubleQuotes, StartLocation = start, EndLocation = t.EndLocation });
-		} else if (la.kind == 12) {
-			Get();
-			Expression innerExpression;
-			Expr(out innerExpression);
-			Expect(13);
-			attrs.Add(new XmlEmbeddedExpression() { InlineVBExpression = innerExpression, StartLocation = start, EndLocation = t.EndLocation });
-		} else SynErr(291);
-	}
-
-	void ArgumentList(out List<Expression> arguments) {
-		arguments = new List<Expression>();
-		Expression expr = null;
-
-		if (StartOf(24)) {
-			Argument(out expr);
-		}
-		while (la.kind == 22) {
-			Get();
-			arguments.Add(expr ?? Expression.Null); expr = null;
-			if (StartOf(24)) {
-				Argument(out expr);
-			}
-			if (expr == null) expr = Expression.Null;
-		}
-		if (expr != null) arguments.Add(expr);
-	}
-
-	void ConjunctionExpr(out Expression outExpr) {
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-
-		NotExpr(out outExpr);
-		while (la.kind == 60 || la.kind == 61) {
-			if (la.kind == 60) {
-				Get();
-				op = BinaryOperatorType.BitwiseAnd;
-			} else {
-				Get();
-				op = BinaryOperatorType.LogicalAnd;
-			}
-			NotExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void NotExpr(out Expression outExpr) {
-		UnaryOperatorType uop = UnaryOperatorType.None;
-		while (la.kind == 164) {
-			Get();
-			uop = UnaryOperatorType.Not;
-		}
-		ComparisonExpr(out outExpr);
-		if (uop != UnaryOperatorType.None)
-		    outExpr = new UnaryOperatorExpression(outExpr, uop);
-
-	}
-
-	void ComparisonExpr(out Expression outExpr) {
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-
-		ShiftExpr(out outExpr);
-		while (StartOf(40)) {
-			switch (la.kind) {
-			case 40: {
-				Get();
-				op = BinaryOperatorType.LessThan;
-				break;
-			}
-			case 39: {
-				Get();
-				op = BinaryOperatorType.GreaterThan;
-				break;
-			}
-			case 43: {
-				Get();
-				op = BinaryOperatorType.LessThanOrEqual;
-				break;
-			}
-			case 42: {
-				Get();
-				op = BinaryOperatorType.GreaterThanOrEqual;
-				break;
-			}
-			case 41: {
-				Get();
-				op = BinaryOperatorType.InEquality;
-				break;
-			}
-			case 20: {
-				Get();
-				op = BinaryOperatorType.Equality;
-				break;
-			}
-			case 150: {
-				Get();
-				op = BinaryOperatorType.Like;
-				break;
-			}
-			case 144: {
-				Get();
-				op = BinaryOperatorType.ReferenceEquality;
-				break;
-			}
-			case 145: {
-				Get();
-				op = BinaryOperatorType.ReferenceInequality;
-				break;
-			}
-			}
-			if (StartOf(41)) {
-				ShiftExpr(out expr);
-				outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-			} else if (la.kind == 164) {
-				Location startLocation2 = la.Location;
-				Get();
-				ShiftExpr(out expr);
-				outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not) { StartLocation = startLocation2, EndLocation = t.EndLocation }) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-			} else SynErr(292);
-		}
-	}
-
-	void ShiftExpr(out Expression outExpr) {
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-
-		ConcatenationExpr(out outExpr);
-		while (la.kind == 44 || la.kind == 45) {
-			if (la.kind == 44) {
-				Get();
-				op = BinaryOperatorType.ShiftLeft;
-			} else {
-				Get();
-				op = BinaryOperatorType.ShiftRight;
-			}
-			ConcatenationExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void ConcatenationExpr(out Expression outExpr) {
-		Expression expr; Location startLocation = la.Location;
-		AdditiveExpr(out outExpr);
-		while (la.kind == 23) {
-			Get();
-			AdditiveExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void AdditiveExpr(out Expression outExpr) {
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-
-		ModuloExpr(out outExpr);
-		while (la.kind == 30 || la.kind == 31) {
-			if (la.kind == 31) {
-				Get();
-				op = BinaryOperatorType.Add;
-			} else {
-				Get();
-				op = BinaryOperatorType.Subtract;
-			}
-			ModuloExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void ModuloExpr(out Expression outExpr) {
-		Expression expr; Location startLocation = la.Location;
-		IntegerDivisionExpr(out outExpr);
-		while (la.kind == 154) {
-			Get();
-			IntegerDivisionExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void IntegerDivisionExpr(out Expression outExpr) {
-		Expression expr; Location startLocation = la.Location;
-		MultiplicativeExpr(out outExpr);
-		while (la.kind == 25) {
-			Get();
-			MultiplicativeExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void MultiplicativeExpr(out Expression outExpr) {
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-
-		UnaryExpr(out outExpr);
-		while (la.kind == 24 || la.kind == 34) {
-			if (la.kind == 34) {
-				Get();
-				op = BinaryOperatorType.Multiply;
-			} else {
-				Get();
-				op = BinaryOperatorType.Divide;
-			}
-			UnaryExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };
-		}
-	}
-
-	void UnaryExpr(out Expression uExpr) {
-		Expression expr;
-		UnaryOperatorType uop = UnaryOperatorType.None;
-		Location startLocation = la.Location;
-		bool isUOp = false;
-
-		while (la.kind == 30 || la.kind == 31 || la.kind == 34) {
-			if (la.kind == 31) {
-				Get();
-				uop = UnaryOperatorType.Plus; isUOp = true;
-			} else if (la.kind == 30) {
-				Get();
-				uop = UnaryOperatorType.Minus; isUOp = true;
-			} else {
-				Get();
-				uop = UnaryOperatorType.Dereference;  isUOp = true;
-			}
-		}
-		ExponentiationExpr(out expr);
-		if (isUOp) {
-				uExpr = new UnaryOperatorExpression(expr, uop) { StartLocation = startLocation, EndLocation = t.EndLocation };
-			} else {
-				uExpr = expr;
-			}
-
-	}
-
-	void ExponentiationExpr(out Expression outExpr) {
-		Expression expr; Location startLocation = la.Location;
-		SimpleExpr(out outExpr);
-		while (la.kind == 32) {
-			Get();
-			SimpleExpr(out expr);
-			outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; 
-		}
-	}
-
-	void NormalOrReDimArgumentList(out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim) {
-		arguments = new List<Expression>();
-		canBeNormal = true; canBeRedim = !IsNamedAssign();
-		Expression expr = null;
-
-		if (StartOf(24)) {
-			Argument(out expr);
-			if (la.kind == 216) {
-				Get();
-				EnsureIsZero(expr); canBeNormal = false;
-				Expr(out expr);
-			}
-		}
-		while (la.kind == 22) {
-			Get();
-			if (expr == null) canBeRedim = false;
-			arguments.Add(expr ?? Expression.Null); expr = null;
-			canBeRedim &= !IsNamedAssign();
-			if (StartOf(24)) {
-				Argument(out expr);
-				if (la.kind == 216) {
-					Get();
-					EnsureIsZero(expr); canBeNormal = false;
-					Expr(out expr);
-				}
-			}
-			if (expr == null) { canBeRedim = false; expr = Expression.Null; }
-		}
-		if (expr != null) arguments.Add(expr); else canBeRedim = false;
-	}
-
-	void ArrayTypeModifiers(out ArrayList arrayModifiers) {
-		arrayModifiers = new ArrayList();
-		int i = 0;
-
-		while (IsDims()) {
-			Expect(37);
-			if (la.kind == 22 || la.kind == 38) {
-				RankList(out i);
-			}
-			arrayModifiers.Add(i);
-
-			Expect(38);
-		}
-		if(arrayModifiers.Count == 0) {
-				 arrayModifiers = null;
-			}
-
-	}
-
-	void MemberInitializer(out MemberInitializerExpression memberInitializer) {
-		memberInitializer = new MemberInitializerExpression();
-		memberInitializer.StartLocation = la.Location;
-		Expression initExpr = null;
-		bool isKey = false;
-		string name = null;
-
-		if (la.kind == 147) {
-			Get();
-			isKey = true;
-		}
-		Expect(26);
-		IdentifierOrKeyword(out name);
-		Expect(20);
-		Expr(out initExpr);
-		memberInitializer.Name = name;
-			memberInitializer.Expression = initExpr;
-			memberInitializer.IsKey = isKey;
-			memberInitializer.EndLocation = t.EndLocation;
-
-	}
-
-	void SubLambdaExpression(out LambdaExpression lambda) {
-		lambda = new LambdaExpression();
-		lambda.ReturnType = new TypeReference("System.Void", true);
-		Statement statement = null;
-		lambda.StartLocation = la.Location;
-
-		Expect(210);
-		Expect(37);
-		if (StartOf(7)) {
-			FormalParameterList(lambda.Parameters);
-		}
-		Expect(38);
-		if (StartOf(1)) {
-			EmbeddedStatement(out statement);
-			lambda.StatementBody = statement;
-				lambda.EndLocation = t.EndLocation;
-				lambda.ExtendedEndLocation = la.Location;
-
-		} else if (la.kind == 1) {
-			Get();
-			Block(out statement);
-			Expect(113);
-			Expect(210);
-			lambda.StatementBody = statement;
-				lambda.EndLocation = t.EndLocation;
-				lambda.ExtendedEndLocation = la.Location;
-
-		} else SynErr(293);
-	}
-
-	void FunctionLambdaExpression(out LambdaExpression lambda) {
-		lambda = new LambdaExpression();
-		TypeReference typeRef = null;
-		Expression inner = null;
-		Statement statement = null;
-		lambda.StartLocation = la.Location;
-
-		Expect(127);
-		Expect(37);
-		if (StartOf(7)) {
-			FormalParameterList(lambda.Parameters);
-		}
-		Expect(38);
-		if (la.kind == 63) {
-			Get();
-			TypeName(out typeRef);
-			lambda.ReturnType = typeRef;
-		}
-		if (StartOf(24)) {
-			Expr(out inner);
-			lambda.ExpressionBody = inner;
-				lambda.EndLocation = t.EndLocation;
-				lambda.ExtendedEndLocation = la.Location;
-
-		} else if (la.kind == 1) {
-			Get();
-			Block(out statement);
-			Expect(113);
-			Expect(127);
-			lambda.StatementBody = statement;
-				lambda.EndLocation = t.EndLocation;
-				lambda.ExtendedEndLocation = la.Location;
-
-		} else SynErr(294);
-	}
-
-	void EmbeddedStatement(out Statement statement) {
-		statement = null;
-		string name = String.Empty;
-		Location startLocation = la.Location;
-
-		if (la.kind == 120) {
-			ExitStatement(out statement);
-		} else if (la.kind == 218) {
-			TryStatement(out statement);
-		} else if (la.kind == 89) {
-			ContinueStatement(out statement);
-		} else if (la.kind == 215) {
-			ThrowStatement(out statement);
-		} else if (la.kind == 195) {
-			ReturnStatement(out statement);
-		} else if (la.kind == 211) {
-			SyncLockStatement(out statement);
-		} else if (la.kind == 189) {
-			RaiseEventStatement(out statement);
-		} else if (la.kind == 233) {
-			WithStatement(out statement);
-		} else if (la.kind == 56) {
-			AddHandlerStatement(out statement);
-		} else if (la.kind == 193) {
-			RemoveHandlerStatement(out statement);
-		} else if (la.kind == 231) {
-			WhileStatement(out statement);
-		} else if (la.kind == 108) {
-			DoLoopStatement(out statement);
-		} else if (la.kind == 124) {
-			ForStatement(out statement);
-		} else if (la.kind == 118) {
-			ErrorStatement(out statement);
-		} else if (la.kind == 191) {
-			ReDimStatement(out statement);
-		} else if (la.kind == 117) {
-			EraseStatement(out statement);
-		} else if (la.kind == 206) {
-			StopStatement(out statement);
-		} else if (la.kind == 135) {
-			IfStatement(out statement);
-		} else if (la.kind == 197) {
-			SelectStatement(out statement);
-		} else if (la.kind == 171) {
-			OnErrorStatement onErrorStatement = null;
-			OnErrorStatement(out onErrorStatement);
-			statement = onErrorStatement;
-		} else if (la.kind == 132) {
-			GotoStatement goToStatement = null;
-			GotoStatement(out goToStatement);
-			statement = goToStatement;
-		} else if (la.kind == 194) {
-			ResumeStatement(out statement);
-		} else if (StartOf(42)) {
-			ExpressionStatement(out statement);
-		} else if (la.kind == 73) {
-			InvocationStatement(out statement);
-		} else if (la.kind == 226) {
-			UsingStatement(out statement);
-		} else if (StartOf(43)) {
-			LocalDeclarationStatement(out statement);
-		} else SynErr(295);
-		if (statement != null) {
-				statement.StartLocation = startLocation;
-				statement.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void FromOrAggregateQueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionFromClause fromClause = null;
-		QueryExpressionAggregateClause aggregateClause = null;
-
-		if (la.kind == 126) {
-			FromQueryOperator(out fromClause);
-			middleClauses.Add(fromClause);
-		} else if (la.kind == 58) {
-			AggregateQueryOperator(out aggregateClause);
-			middleClauses.Add(aggregateClause);
-		} else SynErr(296);
-	}
-
-	void QueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionJoinVBClause joinClause = null;
-		QueryExpressionGroupVBClause groupByClause = null;
-		QueryExpressionPartitionVBClause partitionClause = null;
-		QueryExpressionGroupJoinVBClause groupJoinClause = null;
-		QueryExpressionFromClause fromClause = null;
-		QueryExpressionAggregateClause aggregateClause = null;
-
-		if (la.kind == 126) {
-			FromQueryOperator(out fromClause);
-			middleClauses.Add(fromClause);
-		} else if (la.kind == 58) {
-			AggregateQueryOperator(out aggregateClause);
-			middleClauses.Add(aggregateClause);
-		} else if (la.kind == 197) {
-			SelectQueryOperator(middleClauses);
-		} else if (la.kind == 107) {
-			DistinctQueryOperator(middleClauses);
-		} else if (la.kind == 230) {
-			WhereQueryOperator(middleClauses);
-		} else if (la.kind == 176) {
-			OrderByQueryOperator(middleClauses);
-		} else if (la.kind == 203 || la.kind == 212) {
-			PartitionQueryOperator(out partitionClause);
-			middleClauses.Add(partitionClause);
-		} else if (la.kind == 148) {
-			LetQueryOperator(middleClauses);
-		} else if (la.kind == 146) {
-			JoinQueryOperator(out joinClause);
-			middleClauses.Add(joinClause);
-		} else if (la.kind == Tokens.Group && Peek(1).kind == Tokens.Join) {
-			GroupJoinQueryOperator(out groupJoinClause);
-			middleClauses.Add(groupJoinClause);
-		} else if (la.kind == 133) {
-			GroupByQueryOperator(out groupByClause);
-			middleClauses.Add(groupByClause);
-		} else SynErr(297);
-	}
-
-	void FromQueryOperator(out QueryExpressionFromClause fromClause) {
-		fromClause = new QueryExpressionFromClause();
-		fromClause.StartLocation = la.Location;
-
-		Expect(126);
-		CollectionRangeVariableDeclarationList(fromClause.Sources);
-		fromClause.EndLocation = t.EndLocation;
-
-	}
-
-	void AggregateQueryOperator(out QueryExpressionAggregateClause aggregateClause) {
-		aggregateClause = new QueryExpressionAggregateClause();
-		aggregateClause.IntoVariables = new List<ExpressionRangeVariable>();
-		aggregateClause.StartLocation = la.Location;
-		CollectionRangeVariable source;
-
-		Expect(58);
-		CollectionRangeVariableDeclaration(out source);
-		aggregateClause.Source = source;
-
-		while (StartOf(31)) {
-			QueryOperator(aggregateClause.MiddleClauses);
-		}
-		Expect(143);
-		ExpressionRangeVariableDeclarationList(aggregateClause.IntoVariables);
-		aggregateClause.EndLocation = t.EndLocation;
-
-	}
-
-	void SelectQueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionSelectVBClause selectClause = new QueryExpressionSelectVBClause();
-		selectClause.StartLocation = la.Location;
-
-		Expect(197);
-		ExpressionRangeVariableDeclarationList(selectClause.Variables);
-		selectClause.EndLocation = t.Location;
-			middleClauses.Add(selectClause);
-
-	}
-
-	void DistinctQueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionDistinctClause distinctClause = new QueryExpressionDistinctClause();
-		distinctClause.StartLocation = la.Location;
-
-		Expect(107);
-		distinctClause.EndLocation = t.EndLocation;
-			middleClauses.Add(distinctClause);
-
-	}
-
-	void WhereQueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionWhereClause whereClause = new QueryExpressionWhereClause();
-		whereClause.StartLocation = la.Location;
-		Expression operand = null;
-
-		Expect(230);
-		Expr(out operand);
-		whereClause.Condition = operand;
-			whereClause.EndLocation = t.EndLocation;
-			
-			middleClauses.Add(whereClause);
-
-	}
-
-	void OrderByQueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionOrderClause orderClause = new QueryExpressionOrderClause();
-		orderClause.StartLocation = la.Location;
-		List<QueryExpressionOrdering> orderings = null;
-
-		Expect(176);
-		Expect(70);
-		OrderExpressionList(out orderings);
-		orderClause.Orderings = orderings;
-			orderClause.EndLocation = t.EndLocation;
-			middleClauses.Add(orderClause);
-
-	}
-
-	void PartitionQueryOperator(out QueryExpressionPartitionVBClause partitionClause) {
-		partitionClause = new QueryExpressionPartitionVBClause();
-		partitionClause.StartLocation = la.Location;
-		Expression expr = null;
-
-		if (la.kind == 212) {
-			Get();
-			partitionClause.PartitionType = QueryExpressionPartitionType.Take;
-			if (la.kind == 231) {
-				Get();
-				partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile;
-			}
-		} else if (la.kind == 203) {
-			Get();
-			partitionClause.PartitionType = QueryExpressionPartitionType.Skip;
-			if (la.kind == 231) {
-				Get();
-				partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile;
-			}
-		} else SynErr(298);
-		Expr(out expr);
-		partitionClause.Expression = expr;
-			partitionClause.EndLocation = t.EndLocation;
-
-	}
-
-	void LetQueryOperator(List<QueryExpressionClause> middleClauses) {
-		QueryExpressionLetVBClause letClause = new QueryExpressionLetVBClause();
-		letClause.StartLocation = la.Location;
-
-		Expect(148);
-		ExpressionRangeVariableDeclarationList(letClause.Variables);
-		letClause.EndLocation = t.EndLocation;
-			middleClauses.Add(letClause);
-
-	}
-
-	void JoinQueryOperator(out QueryExpressionJoinVBClause joinClause) {
-		joinClause = new QueryExpressionJoinVBClause();
-		joinClause.StartLocation = la.Location;
-		CollectionRangeVariable joinVariable = null;
-		QueryExpressionJoinVBClause subJoin = null;
-		QueryExpressionJoinConditionVB condition = null;
-
-
-		Expect(146);
-		CollectionRangeVariableDeclaration(out joinVariable);
-		joinClause.JoinVariable = joinVariable;
-		if (la.kind == 146) {
-			JoinQueryOperator(out subJoin);
-			joinClause.SubJoin = subJoin;
-		}
-		Expect(171);
-		JoinCondition(out condition);
-		SafeAdd(joinClause, joinClause.Conditions, condition);
-		while (la.kind == 60) {
-			Get();
-			JoinCondition(out condition);
-			SafeAdd(joinClause, joinClause.Conditions, condition);
-		}
-		joinClause.EndLocation = t.EndLocation;
-
-	}
-
-	void GroupJoinQueryOperator(out QueryExpressionGroupJoinVBClause groupJoinClause) {
-		groupJoinClause = new QueryExpressionGroupJoinVBClause();
-		groupJoinClause.StartLocation = la.Location;
-		QueryExpressionJoinVBClause joinClause = null;
-
-		Expect(133);
-		JoinQueryOperator(out joinClause);
-		Expect(143);
-		ExpressionRangeVariableDeclarationList(groupJoinClause.IntoVariables);
-		groupJoinClause.JoinClause = joinClause;
-			groupJoinClause.EndLocation = t.EndLocation;
-
-	}
-
-	void GroupByQueryOperator(out QueryExpressionGroupVBClause groupByClause) {
-		groupByClause = new QueryExpressionGroupVBClause();
-		groupByClause.StartLocation = la.Location;
-
-		Expect(133);
-		ExpressionRangeVariableDeclarationList(groupByClause.GroupVariables);
-		Expect(70);
-		ExpressionRangeVariableDeclarationList(groupByClause.ByVariables);
-		Expect(143);
-		ExpressionRangeVariableDeclarationList(groupByClause.IntoVariables);
-		groupByClause.EndLocation = t.EndLocation;
-
-	}
-
-	void OrderExpressionList(out List<QueryExpressionOrdering> orderings) {
-		orderings = new List<QueryExpressionOrdering>();
-		QueryExpressionOrdering ordering = null;
-
-		OrderExpression(out ordering);
-		orderings.Add(ordering);
-		while (la.kind == 22) {
-			Get();
-			OrderExpression(out ordering);
-			orderings.Add(ordering);
-		}
-	}
-
-	void OrderExpression(out QueryExpressionOrdering ordering) {
-		ordering = new QueryExpressionOrdering();
-		ordering.StartLocation = la.Location;
-		ordering.Direction = QueryExpressionOrderingDirection.None;
-		Expression orderExpr = null;
-
-		Expr(out orderExpr);
-		ordering.Criteria = orderExpr;
-
-		if (la.kind == 64 || la.kind == 104) {
-			if (la.kind == 64) {
-				Get();
-				ordering.Direction = QueryExpressionOrderingDirection.Ascending;
-			} else {
-				Get();
-				ordering.Direction = QueryExpressionOrderingDirection.Descending;
-			}
-		}
-		ordering.EndLocation = t.EndLocation;
-	}
-
-	void ExpressionRangeVariableDeclarationList(List<ExpressionRangeVariable> variables) {
-		ExpressionRangeVariable variable = null;
-
-		ExpressionRangeVariableDeclaration(out variable);
-		variables.Add(variable);
-		while (la.kind == 22) {
-			Get();
-			ExpressionRangeVariableDeclaration(out variable);
-			variables.Add(variable);
-		}
-	}
-
-	void CollectionRangeVariableDeclarationList(List<CollectionRangeVariable> rangeVariables) {
-		CollectionRangeVariable variableDeclaration;
-		CollectionRangeVariableDeclaration(out variableDeclaration);
-		rangeVariables.Add(variableDeclaration);
-		while (la.kind == 22) {
-			Get();
-			CollectionRangeVariableDeclaration(out variableDeclaration);
-			rangeVariables.Add(variableDeclaration);
-		}
-	}
-
-	void CollectionRangeVariableDeclaration(out CollectionRangeVariable rangeVariable) {
-		rangeVariable = new CollectionRangeVariable();
-		rangeVariable.StartLocation = la.Location;
-		TypeReference typeName = null;
-		Expression inExpr = null;
-
-		Identifier();
-		rangeVariable.Identifier = t.val;
-		if (la.kind == 63) {
-			Get();
-			TypeName(out typeName);
-			rangeVariable.Type = typeName;
-		}
-		Expect(138);
-		Expr(out inExpr);
-		rangeVariable.Expression = inExpr;
-			rangeVariable.EndLocation = t.EndLocation;
-
-	}
-
-	void ExpressionRangeVariableDeclaration(out ExpressionRangeVariable variable) {
-		variable = new ExpressionRangeVariable();
-		variable.StartLocation = la.Location;
-		Expression rhs = null;
-		TypeReference typeName = null;
-
-		if (IsIdentifiedExpressionRange()) {
-			Identifier();
-			variable.Identifier = t.val;
-			if (la.kind == 63) {
-				Get();
-				TypeName(out typeName);
-				variable.Type = typeName;
-			}
-			Expect(20);
-		}
-		Expr(out rhs);
-		variable.Expression = rhs;
-			variable.EndLocation = t.EndLocation;
-
-	}
-
-	void JoinCondition(out QueryExpressionJoinConditionVB condition) {
-		condition = new QueryExpressionJoinConditionVB();
-		condition.StartLocation = la.Location;
-
-		Expression lhs = null;
-		Expression rhs = null;
-
-		Expr(out lhs);
-		Expect(116);
-		Expr(out rhs);
-		condition.LeftSide = lhs;
-			condition.RightSide = rhs;
-			condition.EndLocation = t.EndLocation;
-
-	}
-
-	void Argument(out Expression argumentexpr) {
-		Expression expr;
-		argumentexpr = null;
-		string name;
-		Location startLocation = la.Location;
-
-		if (IsNamedAssign()) {
-			Identifier();
-			name = t.val; 
-			Expect(55);
-			Expr(out expr);
-			argumentexpr = new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };
-
-		} else if (StartOf(24)) {
-			Expr(out argumentexpr);
-		} else SynErr(299);
-	}
-
-	void QualIdentAndTypeArguments(out TypeReference typeref, bool canBeUnbound) {
-		string name; typeref = null;
-		Qualident(out name);
-		typeref = new TypeReference(name);
-		if (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of) {
-			Expect(37);
-			Expect(169);
-			if (canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma)) {
-				typeref.GenericTypes.Add(NullTypeReference.Instance);
-				while (la.kind == 22) {
-					Get();
-					typeref.GenericTypes.Add(NullTypeReference.Instance);
-				}
-			} else if (StartOf(9)) {
-				TypeArgumentList(typeref.GenericTypes);
-			} else SynErr(300);
-			Expect(38);
-		}
-	}
-
-	void RankList(out int i) {
-		i = 0;
-		while (la.kind == 22) {
-			Get();
-			++i;
-		}
-	}
-
-	void Attribute(out ASTAttribute attribute) {
-		string name;
-		List<Expression> positional = new List<Expression>();
-		List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
-		Location startLocation = la.Location;
-
-		if (la.kind == 130) {
-			Get();
-			Expect(26);
-		}
-		Qualident(out name);
-		if (la.kind == 37) {
-			AttributeArguments(positional, named);
-		}
-		attribute  = new ASTAttribute(name, positional, named) { StartLocation = startLocation, EndLocation = t.EndLocation };
-
-	}
-
-	void AttributeArguments(List<Expression> positional, List<NamedArgumentExpression> named) {
-		bool nameFound = false;
-		string name = "";
-		Expression expr;
-
-		Expect(37);
-		if (IsNotClosingParenthesis()) {
-			Location startLocation = la.Location;
-			if (IsNamedAssign()) {
-				nameFound = true;
-				IdentifierOrKeyword(out name);
-				if (la.kind == 55) {
-					Get();
-				} else if (la.kind == 20) {
-					Get();
-				} else SynErr(301);
-			}
-			Expr(out expr);
-			if (expr != null) {
-					if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
-					else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
-				}
-
-			while (la.kind == 22) {
-				Get();
-				if (IsNamedAssign()) {
-					nameFound = true;
-					IdentifierOrKeyword(out name);
-					if (la.kind == 55) {
-						Get();
-					} else if (la.kind == 20) {
-						Get();
-					} else SynErr(302);
-				} else if (StartOf(24)) {
-					if (nameFound) Error("no positional argument after named argument");
-				} else SynErr(303);
-				Expr(out expr);
-				if (expr != null) { if(name == "") positional.Add(expr);
-					else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
-					}
-
-			}
+		default: SynErr(243); break;
 		}
-		Expect(38);
-	}
-
-	void ParameterModifier(ParamModifierList m) {
-		if (la.kind == 72) {
-			Get();
-			m.Add(ParameterModifiers.In);
-		} else if (la.kind == 69) {
-			Get();
-			m.Add(ParameterModifiers.Ref);
-		} else if (la.kind == 174) {
-			Get();
-			m.Add(ParameterModifiers.Optional);
-		} else if (la.kind == 182) {
-			Get();
-			m.Add(ParameterModifiers.Params);
-		} else SynErr(304);
-	}
-
-	void Statement() {
-		Statement stmt = null;
-		Location startPos = la.Location;
-		string label = String.Empty;
-
-		if (IsLabel()) {
-			LabelName(out label);
-			AddChild(new LabelStatement(t.val));
-
-			Expect(21);
-			Statement();
-		} else if (StartOf(1)) {
-			EmbeddedStatement(out stmt);
-			AddChild(stmt);
-		} else SynErr(305);
-		if (stmt != null) {
-				stmt.StartLocation = startPos;
-				stmt.EndLocation = t.Location;
-			}
-
-	}
-
-	void LabelName(out string name) {
-		name = string.Empty;
-
-		if (StartOf(5)) {
-			Identifier();
-			name = t.val;
-		} else if (la.kind == 5) {
-			Get();
-			name = t.val;
-		} else SynErr(306);
 	}
 
-	void LocalDeclarationStatement(out Statement statement) {
-		ModifierList m = new ModifierList();
-		LocalVariableDeclaration localVariableDeclaration;
-		bool dimfound = false;
-
-		while (la.kind == 88 || la.kind == 105 || la.kind == 204) {
-			if (la.kind == 88) {
-				Get();
-				m.Add(Modifiers.Const, t.Location);
-			} else if (la.kind == 204) {
-				Get();
-				m.Add(Modifiers.Static, t.Location);
-			} else {
-				Get();
-				dimfound = true;
-			}
-		}
-		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
-				Error("Dim is not allowed on constants.");
-			}
-			
-			if(m.isNone && dimfound == false) {
-				Error("Const, Dim or Static expected");
-			}
-			
-			localVariableDeclaration = new LocalVariableDeclaration(m.Modifier);
-			localVariableDeclaration.StartLocation = t.Location;
-
-		VariableDeclarator(localVariableDeclaration.Variables);
-		while (la.kind == 22) {
-			Get();
-			VariableDeclarator(localVariableDeclaration.Variables);
-		}
-		statement = localVariableDeclaration;
-
+	void TypeName(out AstType type) {
+		type = null;
+		if (StartOf(2)) {
+			PrimitiveTypeName(out type);
+		} else if (StartOf(3)) {
+			QualifiedTypeName(out type);
+		} else SynErr(244);
 	}
 
-	void ExitStatement(out Statement statement) {
-		Expect(120);
-		ExitType exitType = ExitType.None;
+	void PrimitiveTypeName(out AstType type) {
+		type = null;
 		switch (la.kind) {
-		case 210: {
+		case 168: {
 			Get();
-			exitType = ExitType.Sub;
+			type = new PrimitiveType("Object", t.Location);
 			break;
 		}
-		case 127: {
+		case 68: {
 			Get();
-			exitType = ExitType.Function;
+			type = new PrimitiveType("Boolean", t.Location);
 			break;
 		}
-		case 186: {
+		case 99: {
 			Get();
-			exitType = ExitType.Property;
+			type = new PrimitiveType("Date", t.Location);
 			break;
 		}
-		case 108: {
+		case 82: {
 			Get();
-			exitType = ExitType.Do;
+			type = new PrimitiveType("Char", t.Location);
 			break;
 		}
-		case 124: {
+		case 208: {
 			Get();
-			exitType = ExitType.For;
+			type = new PrimitiveType("String", t.Location);
 			break;
 		}
-		case 218: {
+		case 100: {
 			Get();
-			exitType = ExitType.Try;
+			type = new PrimitiveType("Decimal", t.Location);
 			break;
 		}
-		case 231: {
+		case 71: {
 			Get();
-			exitType = ExitType.While;
+			type = new PrimitiveType("Byte", t.Location);
 			break;
 		}
-		case 197: {
+		case 201: {
 			Get();
-			exitType = ExitType.Select;
+			type = new PrimitiveType("Short", t.Location);
 			break;
 		}
-		default: SynErr(307); break;
-		}
-		statement = new ExitStatement(exitType);
-	}
-
-	void TryStatement(out Statement tryStatement) {
-		Statement blockStmt = null;
-		Statement finallyStmt = null;
-		CatchClause clause = null;
-		List<CatchClause> catchClauses = new List<CatchClause>();
-
-		Expect(218);
-		EndOfStmt();
-		Block(out blockStmt);
-		while (la.kind == 75) {
-			CatchClause(out clause);
-			if (clause != null) catchClauses.Add(clause);
-		}
-		if (la.kind == 123) {
+		case 141: {
 			Get();
-			EndOfStmt();
-			Block(out finallyStmt);
-		}
-		Expect(113);
-		Expect(218);
-		tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt);
-	}
-
-	void ContinueStatement(out Statement statement) {
-		Expect(89);
-		ContinueType continueType = ContinueType.None;
-		if (la.kind == 108 || la.kind == 124 || la.kind == 231) {
-			if (la.kind == 108) {
-				Get();
-				continueType = ContinueType.Do;
-			} else if (la.kind == 124) {
-				Get();
-				continueType = ContinueType.For;
-			} else {
-				Get();
-				continueType = ContinueType.While;
-			}
-		}
-		statement = new ContinueStatement(continueType);
-	}
-
-	void ThrowStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(215);
-		if (StartOf(24)) {
-			Expr(out expr);
-		}
-		statement = new ThrowStatement(expr);
-	}
-
-	void ReturnStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(195);
-		if (StartOf(24)) {
-			Expr(out expr);
+			type = new PrimitiveType("Integer", t.Location);
+			break;
 		}
-		statement = new ReturnStatement(expr);
-	}
-
-	void SyncLockStatement(out Statement statement) {
-		Expression expr; Statement embeddedStatement;
-		Expect(211);
-		Expr(out expr);
-		EndOfStmt();
-		Block(out embeddedStatement);
-		Expect(113);
-		Expect(211);
-		statement = new LockStatement(expr, embeddedStatement);
-	}
-
-	void RaiseEventStatement(out Statement statement) {
-		List<Expression> arguments = null;
-		Expect(189);
-		Identifier();
-		string name = t.val;
-		if (la.kind == 37) {
+		case 151: {
 			Get();
-			ArgumentList(out arguments);
-			Expect(38);
+			type = new PrimitiveType("Long", t.Location);
+			break;
 		}
-		statement = new RaiseEventStatement(name, arguments);
-	}
-
-	void WithStatement(out Statement withStatement) {
-		Statement blockStmt = null;
-		Expression expr = null;
-
-		Expect(233);
-		Location start = t.Location;
-		Expr(out expr);
-		EndOfStmt();
-		withStatement = new WithStatement(expr);
-			withStatement.StartLocation = start;
-
-		Block(out blockStmt);
-		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
-
-		Expect(113);
-		Expect(233);
-		withStatement.EndLocation = t.Location;
-	}
-
-	void AddHandlerStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(56);
-		Expression handlerExpr = null;
-		Expr(out expr);
-		Expect(22);
-		Expr(out handlerExpr);
-		statement = new AddHandlerStatement(expr, handlerExpr);
-	}
-
-	void RemoveHandlerStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(193);
-		Expression handlerExpr = null;
-		Expr(out expr);
-		Expect(22);
-		Expr(out handlerExpr);
-		statement = new RemoveHandlerStatement(expr, handlerExpr);
-	}
-
-	void WhileStatement(out Statement statement) {
-		Expression expr = null; Statement embeddedStatement;
-		Expect(231);
-		Expr(out expr);
-		EndOfStmt();
-		Block(out embeddedStatement);
-		Expect(113);
-		Expect(231);
-		statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start);
-	}
-
-	void DoLoopStatement(out Statement statement) {
-		Expression expr = null; Statement embeddedStatement; statement = null;
-		Expect(108);
-		ConditionType conditionType = ConditionType.None;
-		if (la.kind == 224 || la.kind == 231) {
-			WhileOrUntil(out conditionType);
-			Expr(out expr);
-			EndOfStmt();
-			Block(out embeddedStatement);
-			Expect(152);
-			statement = new DoLoopStatement(expr, 
-				                                embeddedStatement, 
-				                                conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
-				                                ConditionPosition.Start);
-
-		} else if (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-			Block(out embeddedStatement);
-			Expect(152);
-			if (la.kind == 224 || la.kind == 231) {
-				WhileOrUntil(out conditionType);
-				Expr(out expr);
-			}
-			statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End);
-		} else SynErr(308);
-	}
-
-	void ForStatement(out Statement statement) {
-		Expression expr = null; Statement embeddedStatement; statement = null; Location startLocation = la.Location;
-		Expect(124);
-		Expression group = null;
-				TypeReference typeReference;
-				string        typeName;
-
-		if (la.kind == 110) {
+		case 202: {
 			Get();
-			LoopControlVariable(out typeReference, out typeName);
-			Expect(138);
-			Expr(out group);
-			EndOfStmt();
-			Block(out embeddedStatement);
-			Expect(163);
-			if (StartOf(24)) {
-				Expr(out expr);
-			}
-			statement = new ForeachStatement(typeReference, 
-				                                 typeName,
-				                                 group, 
-				                                 embeddedStatement, 
-				                                 expr);
-				statement.StartLocation = startLocation;
-				statement.EndLocation   = t.EndLocation;
-				
-
-		} else if (StartOf(42)) {
-			Expression start = null;
-				Expression end = null;
-				Expression step = null;
-				Expression variableExpr = null;
-				Expression nextExpr = null;
-				List<Expression> nextExpressions = null;
-
-			if (IsLoopVariableDeclaration()) {
-				LoopControlVariable(out typeReference, out typeName);
-			} else {
-				typeReference = null; typeName = null;
-				SimpleExpr(out variableExpr);
-			}
-			Expect(20);
-			Expr(out start);
-			Expect(216);
-			Expr(out end);
-			if (la.kind == 205) {
-				Get();
-				Expr(out step);
-			}
-			EndOfStmt();
-			Block(out embeddedStatement);
-			Expect(163);
-			if (StartOf(24)) {
-				Expr(out nextExpr);
-				nextExpressions = new List<Expression>();
-					nextExpressions.Add(nextExpr);
-
-				while (la.kind == 22) {
-					Get();
-					Expr(out nextExpr);
-					nextExpressions.Add(nextExpr);
-				}
-			}
-			statement = new ForNextStatement {
-					TypeReference = typeReference,
-					VariableName = typeName, 
-					LoopVariableExpression = variableExpr,
-					Start = start, 
-					End = end, 
-					Step = step, 
-					EmbeddedStatement = embeddedStatement, 
-					NextExpressions = nextExpressions
-				};
-
-		} else SynErr(309);
-	}
-
-	void ErrorStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(118);
-		Expr(out expr);
-		statement = new ErrorStatement(expr);
-	}
-
-	void ReDimStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(191);
-		bool isPreserve = false;
-		if (la.kind == 184) {
-			Expect(184);
-			isPreserve = true;
+			type = new PrimitiveType("Single", t.Location);
+			break;
 		}
-		ReDimClause(out expr);
-		ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
-			statement = reDimStatement;
-			SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
-
-		while (la.kind == 22) {
+		case 109: {
 			Get();
-			ReDimClause(out expr);
-			SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
+			type = new PrimitiveType("Double", t.Location);
+			break;
 		}
-	}
-
-	void EraseStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(117);
-		Expr(out expr);
-		EraseStatement eraseStatement = new EraseStatement();
-			if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
-
-		while (la.kind == 22) {
+		case 221: {
 			Get();
-			Expr(out expr);
-			if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }
+			type = new PrimitiveType("UInteger", t.Location);
+			break;
 		}
-		statement = eraseStatement;
-	}
-
-	void StopStatement(out Statement statement) {
-		Expect(206);
-		statement = new StopStatement();
-	}
-
-	void IfStatement(out Statement statement) {
-		Expression expr = null; Statement embeddedStatement; statement = null;
-		Expect(135);
-		Location ifStartLocation = t.Location;
-		Expr(out expr);
-		if (la.kind == 214) {
+		case 222: {
 			Get();
+			type = new PrimitiveType("ULong", t.Location);
+			break;
 		}
-		if (la.kind == 1 || la.kind == 21) {
-			EndOfStmt();
-			Block(out embeddedStatement);
-			IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
-				ifStatement.StartLocation = ifStartLocation;
-				Location elseIfStart;
-
-			while (la.kind == 112 || (IsElseIf())) {
-				if (IsElseIf()) {
-					Expect(111);
-					elseIfStart = t.Location;
-					Expect(135);
-				} else {
-					Get();
-					elseIfStart = t.Location;
-				}
-				Expression condition = null; Statement block = null;
-				Expr(out condition);
-				if (la.kind == 214) {
-					Get();
-				}
-				EndOfStmt();
-				Block(out block);
-				ElseIfSection elseIfSection = new ElseIfSection(condition, block);
-					elseIfSection.StartLocation = elseIfStart;
-					elseIfSection.EndLocation = t.Location;
-					elseIfSection.Parent = ifStatement;
-					ifStatement.ElseIfSections.Add(elseIfSection);
-
-			}
-			if (la.kind == 111) {
-				Get();
-				if (la.kind == 1 || la.kind == 21) {
-					EndOfStmt();
-				}
-				Block(out embeddedStatement);
-				ifStatement.FalseStatement.Add(embeddedStatement);
-
-			}
-			Expect(113);
-			Expect(135);
-			ifStatement.EndLocation = t.Location;
-				statement = ifStatement;
-
-		} else if (StartOf(44)) {
-			IfElseStatement ifStatement = new IfElseStatement(expr);
-				ifStatement.StartLocation = ifStartLocation;
-
-			SingleLineStatementList(ifStatement.TrueStatement);
-			if (la.kind == 111) {
-				Get();
-				if (StartOf(44)) {
-					SingleLineStatementList(ifStatement.FalseStatement);
-				}
-			}
-			ifStatement.EndLocation = t.Location; statement = ifStatement;
-		} else SynErr(310);
-	}
-
-	void SelectStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(197);
-		if (la.kind == 74) {
+		case 225: {
 			Get();
+			type = new PrimitiveType("UShort", t.Location);
+			break;
 		}
-		Expr(out expr);
-		EndOfStmt();
-		List<SwitchSection> selectSections = new List<SwitchSection>();
-			Statement block = null;
-
-		while (la.kind == 74) {
-			List<CaseLabel> caseClauses = null; Location caseLocation = la.Location;
+		case 196: {
 			Get();
-			CaseClauses(out caseClauses);
-			if (IsNotStatementSeparator()) {
-				Expect(21);
-			}
-			EndOfStmt();
-			SwitchSection selectSection = new SwitchSection(caseClauses);
-				selectSection.StartLocation = caseLocation;
-
-			Block(out block);
-			selectSection.Children = block.Children;
-				selectSection.EndLocation = t.EndLocation;
-				selectSections.Add(selectSection);
-
+			type = new PrimitiveType("SByte", t.Location);
+			break;
 		}
-		statement = new SwitchStatement(expr, selectSections);
-
-		Expect(113);
-		Expect(197);
-	}
-
-	void OnErrorStatement(out OnErrorStatement stmt) {
-		stmt = null;
-		Location startLocation = la.Location;
-		GotoStatement goToStatement = null;
-
-		Expect(171);
-		Expect(118);
-		if (IsNegativeLabelName()) {
-			Expect(132);
-			Expect(30);
-			Expect(5);
-			long intLabel = Int64.Parse(t.val);
-				if(intLabel != 1) {
-					Error("invalid label in on error statement.");
-				}
-				stmt = new OnErrorStatement(new GotoStatement((intLabel * -1).ToString()));
-
-		} else if (la.kind == 132) {
-			GotoStatement(out goToStatement);
-			string val = goToStatement.Label;
-				
-				// if value is numeric, make sure that is 0
-				try {
-					long intLabel = Int64.Parse(val);
-					if(intLabel != 0) {
-						Error("invalid label in on error statement.");
-					}
-				} catch {
-				}
-				stmt = new OnErrorStatement(goToStatement);
-
-		} else if (la.kind == 194) {
-			Get();
-			Expect(163);
-			stmt = new OnErrorStatement(new ResumeStatement(true));
-
-		} else SynErr(311);
-		if (stmt != null) {
-				stmt.StartLocation = startLocation;
-				stmt.EndLocation = t.EndLocation;
-			}
-
-	}
-
-	void GotoStatement(out GotoStatement goToStatement) {
-		string label = string.Empty;
-		Location startLocation = la.Location;
-
-		Expect(132);
-		LabelName(out label);
-		goToStatement = new GotoStatement(label) {
-				StartLocation = startLocation,
-				EndLocation = t.EndLocation
-			};
-
-	}
-
-	void ResumeStatement(out Statement resumeStatement) {
-		resumeStatement = null;
-		string label = string.Empty;
-
-		Expect(194);
-		if (StartOf(45)) {
-			if (la.kind == 163) {
-				Get();
-				resumeStatement = new ResumeStatement(true);
-			} else {
-				LabelName(out label);
-			}
+		default: SynErr(245); break;
 		}
-		resumeStatement = new ResumeStatement(label);
-	}
-
-	void ExpressionStatement(out Statement statement) {
-		Expression expr = null;
-		Expression val = null;
-			AssignmentOperatorType op;
-			Location startLoc = la.Location;
-			
-			bool mustBeAssignment = la.kind == Tokens.Plus  || la.kind == Tokens.Minus ||
-			                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
-
-		SimpleExpr(out expr);
-		if (StartOf(46)) {
-			AssignmentOperator(out op);
-			Expr(out val);
-			expr = new AssignmentExpression(expr, op, val);
-				expr.StartLocation = startLoc;
-				expr.EndLocation = t.EndLocation;
-
-		} else if (la.kind == 1 || la.kind == 21 || la.kind == 111) {
-			if (mustBeAssignment) Error("error in assignment.");
-		} else SynErr(312);
-		if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
-				Location endLocation = expr.EndLocation;
-				expr = new InvocationExpression(expr);
-				expr.StartLocation = startLoc;
-				expr.EndLocation = endLocation;
-			}
-			statement = new ExpressionStatement(expr);
-
-	}
-
-	void InvocationStatement(out Statement statement) {
-		Expression expr = null;
-		Expect(73);
-		SimpleExpr(out expr);
-		statement = new ExpressionStatement(expr);
-	}
-
-	void UsingStatement(out Statement statement) {
-		Expression expr = null; Statement block; statement = null;
-		Expect(226);
-		if (Peek(1).kind == Tokens.As) {
-			LocalVariableDeclaration resourceAquisition = 
-			new LocalVariableDeclaration(Modifiers.None);
-			VariableDeclarator(resourceAquisition.Variables);
-			while (la.kind == 22) {
-				Get();
-				VariableDeclarator(resourceAquisition.Variables);
-			}
-			EndOfStmt();
-			Block(out block);
-			statement = new UsingStatement(resourceAquisition, block);
-		} else if (StartOf(24)) {
-			Expr(out expr);
-			EndOfStmt();
-			Block(out block);
-			statement = new UsingStatement(new ExpressionStatement(expr), block);
-		} else SynErr(313);
-		Expect(113);
-		Expect(226);
 	}
 
-	void WhileOrUntil(out ConditionType conditionType) {
-		conditionType = ConditionType.None;
-		if (la.kind == 231) {
-			Get();
-			conditionType = ConditionType.While;
-		} else if (la.kind == 224) {
+	void QualifiedTypeName(out AstType type) {
+		if (la.kind == 130) {
 			Get();
-			conditionType = ConditionType.Until;
-		} else SynErr(314);
-	}
-
-	void LoopControlVariable(out TypeReference type, out string name) {
-		ArrayList arrayModifiers = null;
-		type = null;
-
-		Qualident(out name);
-		if (IsDims()) {
-			ArrayTypeModifiers(out arrayModifiers);
-		}
-		if (la.kind == 63) {
+		} else if (StartOf(4)) {
+			Identifier();
+		} else SynErr(246);
+		type = new SimpleType(t.val, t.Location);
+		while (la.kind == 26) {
 			Get();
-			TypeName(out type);
-			if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); }
+			Identifier();
+			type = new QualifiedType(type, new Identifier(t.val, t.Location));
 		}
-		if (type != null) {
-				if(type.RankSpecifier != null && arrayModifiers != null) {
-					Error("array rank only allowed one time");
-				} else if (arrayModifiers != null) {
-					type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int));
-				}
-			}
-
-	}
-
-	void ReDimClause(out Expression expr) {
-		SimpleNonInvocationExpression(out expr);
-		ReDimClauseInternal(ref expr);
 	}
 
-	void SingleLineStatementList(List<Statement> list) {
-		Statement embeddedStatement = null;
-		if (la.kind == 113) {
+	void OnOff(OptionStatement os) {
+		if (la.kind == 171) {
 			Get();
-			embeddedStatement = new EndStatement() { StartLocation = t.Location, EndLocation = t.EndLocation };
-		} else if (StartOf(1)) {
-			EmbeddedStatement(out embeddedStatement);
-		} else SynErr(315);
-		if (embeddedStatement != null) list.Add(embeddedStatement);
-		while (la.kind == 21) {
+			AddTerminal(Ast.OptionStatement.OptionValueRole);
+			os.OptionValue = OptionValue.On;
+		} else if (la.kind == 170) {
 			Get();
-			while (la.kind == 21) {
-				Get();
-			}
-			if (la.kind == 113) {
-				Get();
-				embeddedStatement = new EndStatement() { StartLocation = t.Location, EndLocation = t.EndLocation };
-			} else if (StartOf(1)) {
-				EmbeddedStatement(out embeddedStatement);
-			} else SynErr(316);
-			if (embeddedStatement != null) list.Add(embeddedStatement);
-		}
+			AddTerminal(Ast.OptionStatement.OptionValueRole);
+			os.OptionValue  = OptionValue.Off;
+		} else SynErr(247);
 	}
 
-	void CaseClauses(out List<CaseLabel> caseClauses) {
-		caseClauses = new List<CaseLabel>();
-		CaseLabel caseClause = null;
-
-		CaseClause(out caseClause);
-		if (caseClause != null) { caseClauses.Add(caseClause); }
-		while (la.kind == 22) {
+	void BinaryText(OptionStatement os) {
+		if (la.kind == 213) {
 			Get();
-			CaseClause(out caseClause);
-			if (caseClause != null) { caseClauses.Add(caseClause); }
-		}
+			AddTerminal(Ast.OptionStatement.OptionValueRole);
+			os.OptionValue = OptionValue.Text;
+		} else if (la.kind == 67) {
+			Get();
+			AddTerminal(Ast.OptionStatement.OptionValueRole);
+			os.OptionValue  = OptionValue.Binary;
+		} else SynErr(248);
 	}
 
-	void ReDimClauseInternal(ref Expression expr) {
-		List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; Location startLocation = la.Location;
-		while (la.kind == 26 || (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)) {
-			if (la.kind == 26) {
-				Get();
-				IdentifierOrKeyword(out name);
-				expr = new MemberReferenceExpression(expr, name) { StartLocation = startLocation, EndLocation = t.EndLocation };
-			} else {
-				InvocationExpression(ref expr);
-				expr.StartLocation = startLocation;
-					expr.EndLocation = t.EndLocation;
-
-			}
-		}
-		Expect(37);
-		NormalOrReDimArgumentList(out arguments, out canBeNormal, out canBeRedim);
-		Expect(38);
-		expr = new InvocationExpression(expr, arguments);
-			if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
-				if (this.Errors.Count == 0) {
-					// don't recurse on parse errors - could result in endless recursion
-					ReDimClauseInternal(ref expr);
-				}
-			}
-
+	void ImportsClause() {
+		if (IsAliasImportsClause()) {
+			AliasImportsClause(Ast.ImportsStatement.ImportsClauseRole);
+		} else if (StartOf(5)) {
+			MemberImportsClause(Ast.ImportsStatement.ImportsClauseRole);
+		} else if (la.kind == 10) {
+			XmlNamespaceImportsClause(Ast.ImportsStatement.ImportsClauseRole);
+		} else SynErr(249);
+		while (!(StartOf(6))) {SynErr(250); Get();}
 	}
 
-	void CaseClause(out CaseLabel caseClause) {
-		Expression expr = null;
-		Expression sexpr = null;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		caseClause = null;
-
-		if (la.kind == 111) {
-			Get();
-			caseClause = new CaseLabel();
-		} else if (StartOf(47)) {
-			if (la.kind == 144) {
-				Get();
-			}
-			switch (la.kind) {
-			case 40: {
-				Get();
-				op = BinaryOperatorType.LessThan;
-				break;
-			}
-			case 39: {
-				Get();
-				op = BinaryOperatorType.GreaterThan;
-				break;
-			}
-			case 43: {
-				Get();
-				op = BinaryOperatorType.LessThanOrEqual;
-				break;
-			}
-			case 42: {
-				Get();
-				op = BinaryOperatorType.GreaterThanOrEqual;
-				break;
-			}
-			case 20: {
-				Get();
-				op = BinaryOperatorType.Equality;
-				break;
-			}
-			case 41: {
-				Get();
-				op = BinaryOperatorType.InEquality;
-				break;
-			}
-			default: SynErr(317); break;
-			}
-			Expr(out expr);
-			caseClause = new CaseLabel(op, expr);
-
-		} else if (StartOf(24)) {
-			Expr(out expr);
-			if (la.kind == 216) {
-				Get();
-				Expr(out sexpr);
-			}
-			caseClause = new CaseLabel(expr, sexpr);
-
-		} else SynErr(318);
+	void AliasImportsClause(Role role) {
+		var result = new AliasImportsClause(); NodeStart(result);
+		AstType alias;
+		Identifier();
+		result.Name = new Identifier(t.val, t.Location);
+		Expect(20);
+		TypeName(out alias);
+		result.Alias = alias;
+		NodeEnd(result, role);
 	}
 
-	void CatchClause(out CatchClause catchClause) {
-		TypeReference type = null;
-		Statement blockStmt = null;
-		Expression expr = null;
-		string name = String.Empty;
+	void MemberImportsClause(Role role) {
+		var result = new MemberImportsClause(); NodeStart(result);
+		AstType member;
+		TypeName(out member);
+		result.Member = member;
+		NodeEnd(result, role);
+	}
 
-		Expect(75);
-		if (StartOf(5)) {
-			Identifier();
-			name = t.val;
-			if (la.kind == 63) {
-				Get();
-				TypeName(out type);
-			}
-		}
-		if (la.kind == 229) {
-			Get();
-			Expr(out expr);
-		}
-		EndOfStmt();
-		Block(out blockStmt);
-		catchClause = new CatchClause(type, name, blockStmt, expr);
+	void XmlNamespaceImportsClause(Role role) {
+		var result = new XmlNamespaceImportsClause(); NodeStart(result);
+		Expect(10);
+		AddTerminal(Roles.XmlOpenTag);
+		Identifier();
+		Expect(20);
+		AddTerminal(Roles.Assign);
+		Expect(3);
+		Expect(11);
+		AddTerminal(Roles.XmlCloseTag);
+		NodeEnd(result, role);
 	}
 
 
@@ -5094,54 +482,13 @@ partial class VBParser
 	}
 
 	static readonly BitArray[] set = {
-		new BitArray(new int[] {2097155, 0, 0, 0, 0, 0, 0, 0}),
-		new BitArray(new int[] {1007618044, 1191182376, -1051937, 1466973983, -1030969162, -1593504476, -21406146, 711}),
-		new BitArray(new int[] {0, 256, 1048576, 537395328, 402669568, 444596289, 131456, 0}),
-		new BitArray(new int[] {0, 256, 1048576, 537395328, 402669568, 444596288, 131456, 0}),
-		new BitArray(new int[] {0, 0, 0, 536870912, 268435456, 444596288, 384, 0}),
-		new BitArray(new int[] {4, 1140850688, 8388687, 1108347140, 821280, 17105920, -2144335872, 65}),
+		new BitArray(new int[] {6291459, 0, 0, 0, 0, 0, 0, 0}),
 		new BitArray(new int[] {4, 1140850688, 8388687, 1108347136, 821280, 17105920, -2144335872, 65}),
-		new BitArray(new int[] {4, 1140850944, 8388975, 1108347140, 821280, 21316608, -2144335872, 65}),
-		new BitArray(new int[] {4, 1140850688, 9699551, 1108355356, 9218084, 17106180, -533524976, 67}),
-		new BitArray(new int[] {4, 1140850688, 8650975, 1108355356, 9218084, 17106176, -533656048, 67}),
-		new BitArray(new int[] {4, 1140850944, 26214479, -493351964, 940361760, 1606227138, -2143942272, 3393}),
-		new BitArray(new int[] {0, 0, 0, 536871488, 805306368, 1522008256, 384, 3072}),
+		new BitArray(new int[] {0, 0, 262288, 8216, 8396800, 256, 1610679824, 2}),
 		new BitArray(new int[] {4, 1140850688, 8388687, 1108347140, 821284, 17105920, -2144335872, 65}),
-		new BitArray(new int[] {0, 0, 262288, 8216, 8396800, 0, 1610679824, 2}),
-		new BitArray(new int[] {4, 1140850944, 8388687, 1108347140, 821280, 17105920, -2144335872, 65}),
-		new BitArray(new int[] {0, 256, 1048576, -1601699136, 939540480, 1589117120, 393600, 3072}),
-		new BitArray(new int[] {0, 1073741824, 4, -2147483648, 0, 0, -2147221504, 0}),
-		new BitArray(new int[] {2097154, 32, 0, 0, 256, 0, 0, 0}),
-		new BitArray(new int[] {0, 256, 0, 536870912, 1, 436207616, 64, 0}),
-		new BitArray(new int[] {0, 16777472, 0, 0, 0, 536870912, 2, 0}),
-		new BitArray(new int[] {0, 256, 0, -1602223552, 805306368, 1589117120, 262528, 3072}),
-		new BitArray(new int[] {0, 0, 1048576, 524416, 134234112, 0, 131072, 0}),
-		new BitArray(new int[] {-66123780, 1174405164, -51384097, 1175465247, -1030969178, 17106228, -97448432, 67}),
-		new BitArray(new int[] {7340034, -2147483648, 0, 32768, 0, 0, 0, 0}),
-		new BitArray(new int[] {-66123780, 1174405164, -51384097, -972018401, -1030969178, 17106228, -97186288, 67}),
-		new BitArray(new int[] {0, 0, 0, 536870912, 1, 436207616, 0, 0}),
-		new BitArray(new int[] {0, 256, 0, 536870912, 0, 436207616, 64, 0}),
-		new BitArray(new int[] {0, 0, 0, 536870912, 0, 436207616, 64, 0}),
-		new BitArray(new int[] {0, 256, 0, 536870912, 1, 436207616, 0, 0}),
-		new BitArray(new int[] {0, 0, 288, 0, 0, 4210688, 0, 0}),
-		new BitArray(new int[] {0, 0, 0, 536870912, 0, 436207616, 0, 0}),
-		new BitArray(new int[] {0, 67108864, 0, 1073743872, 1310752, 65536, 1050656, 64}),
-		new BitArray(new int[] {1006632960, 32, 0, 0, 0, 0, 0, 0}),
-		new BitArray(new int[] {-2, -1, -1, -1, -1, -1, -1, -1}),
-		new BitArray(new int[] {985084, 1174405160, -51384097, 1175465247, -1030969178, 17106212, -97448432, 67}),
-		new BitArray(new int[] {1006632960, 0, 0, 0, 0, 0, 0, 0}),
-		new BitArray(new int[] {983040, 0, 0, 0, 0, 0, 0, 0}),
-		new BitArray(new int[] {4100, 1140850688, 8388687, 1108347140, 821280, 17105920, -2144335872, 65}),
-		new BitArray(new int[] {988160, 0, 0, 0, 0, 0, 0, 0}),
-		new BitArray(new int[] {-2050, -1, -1, -1, -1, -1, -1, -1}),
-		new BitArray(new int[] {1048576, 3968, 0, 0, 4390912, 0, 0, 0}),
-		new BitArray(new int[] {-66123780, 1174405164, -51384097, 1175465247, -1030969178, 17106212, -97448432, 67}),
-		new BitArray(new int[] {1007618044, 1174405160, -51384097, 1175465247, -1030969178, 17106212, -97448432, 67}),
-		new BitArray(new int[] {4, 1140850688, 25165903, 1108347652, 821280, 17105920, -2144331776, 65}),
-		new BitArray(new int[] {1007618044, 1191182376, -1051937, 1467105055, -1030969162, -1593504476, -21406146, 711}),
-		new BitArray(new int[] {36, 1140850688, 8388687, 1108347140, 821280, 17105928, -2144335872, 65}),
-		new BitArray(new int[] {1048576, 8372224, 0, 0, 0, 0, 0, 0}),
-		new BitArray(new int[] {1048576, 3968, 0, 0, 65536, 0, 0, 0})
+		new BitArray(new int[] {4, 1140850688, 8388687, 1108347140, 821280, 17105920, -2144335872, 65}),
+		new BitArray(new int[] {4, 1140850688, 8650975, 1108355356, 9218084, 17106176, -533656048, 67}),
+		new BitArray(new int[] {6291459, 0, 0, 0, 0, 0, 0, 0})
 
 	};
 	
@@ -5392,86 +739,18 @@ partial class VBParser
 			case 236: return "\"Xor\" expected";
 			case 237: return "\"GetXmlNamespace\" expected";
 			case 238: return "??? expected";
-			case 239: return "this symbol not expected in EndOfStmt";
-			case 240: return "invalid EndOfStmt";
-			case 241: return "invalid OptionStmt";
-			case 242: return "invalid OptionStmt";
-			case 243: return "invalid GlobalAttributeSection";
-			case 244: return "invalid GlobalAttributeSection";
-			case 245: return "invalid NamespaceMemberDecl";
-			case 246: return "invalid OptionValue";
-			case 247: return "invalid ImportClause";
-			case 248: return "invalid Identifier";
-			case 249: return "invalid AttributeSection";
-			case 250: return "invalid TypeModifier";
-			case 251: return "invalid NonModuleDeclaration";
-			case 252: return "invalid NonModuleDeclaration";
-			case 253: return "invalid TypeParameterConstraints";
-			case 254: return "invalid TypeParameterConstraint";
-			case 255: return "invalid NonArrayTypeName";
-			case 256: return "invalid MemberModifier";
-			case 257: return "invalid StructureMemberDecl";
-			case 258: return "invalid StructureMemberDecl";
-			case 259: return "invalid StructureMemberDecl";
-			case 260: return "invalid StructureMemberDecl";
-			case 261: return "invalid StructureMemberDecl";
-			case 262: return "invalid StructureMemberDecl";
-			case 263: return "invalid StructureMemberDecl";
-			case 264: return "invalid StructureMemberDecl";
-			case 265: return "invalid InterfaceMemberDecl";
-			case 266: return "invalid InterfaceMemberDecl";
-			case 267: return "invalid Expr";
-			case 268: return "invalid Block";
-			case 269: return "invalid Charset";
-			case 270: return "invalid IdentifierForFieldDeclaration";
-			case 271: return "invalid VariableDeclaratorPartAfterIdentifier";
-			case 272: return "invalid ObjectCreateExpression";
-			case 273: return "invalid ObjectCreateExpression";
-			case 274: return "invalid AccessorDecls";
-			case 275: return "invalid EventAccessorDeclaration";
-			case 276: return "invalid OverloadableOperator";
-			case 277: return "invalid EventMemberSpecifier";
-			case 278: return "invalid LambdaExpr";
-			case 279: return "invalid AssignmentOperator";
-			case 280: return "invalid SimpleExpr";
-			case 281: return "invalid SimpleNonInvocationExpression";
-			case 282: return "invalid SimpleNonInvocationExpression";
-			case 283: return "invalid PrimitiveTypeName";
-			case 284: return "invalid CastTarget";
-			case 285: return "invalid XmlLiteralExpression";
-			case 286: return "invalid XmlContentExpression";
-			case 287: return "invalid XmlElement";
-			case 288: return "invalid XmlElement";
-			case 289: return "invalid XmlNestedContent";
-			case 290: return "invalid XmlAttribute";
-			case 291: return "invalid XmlAttribute";
-			case 292: return "invalid ComparisonExpr";
-			case 293: return "invalid SubLambdaExpression";
-			case 294: return "invalid FunctionLambdaExpression";
-			case 295: return "invalid EmbeddedStatement";
-			case 296: return "invalid FromOrAggregateQueryOperator";
-			case 297: return "invalid QueryOperator";
-			case 298: return "invalid PartitionQueryOperator";
-			case 299: return "invalid Argument";
-			case 300: return "invalid QualIdentAndTypeArguments";
-			case 301: return "invalid AttributeArguments";
-			case 302: return "invalid AttributeArguments";
-			case 303: return "invalid AttributeArguments";
-			case 304: return "invalid ParameterModifier";
-			case 305: return "invalid Statement";
-			case 306: return "invalid LabelName";
-			case 307: return "invalid ExitStatement";
-			case 308: return "invalid DoLoopStatement";
-			case 309: return "invalid ForStatement";
-			case 310: return "invalid IfStatement";
-			case 311: return "invalid OnErrorStatement";
-			case 312: return "invalid ExpressionStatement";
-			case 313: return "invalid UsingStatement";
-			case 314: return "invalid WhileOrUntil";
-			case 315: return "invalid SingleLineStatementList";
-			case 316: return "invalid SingleLineStatementList";
-			case 317: return "invalid CaseClause";
-			case 318: return "invalid CaseClause";
+			case 239: return "this symbol not expected in StatementTerminator";
+			case 240: return "invalid StatementTerminator";
+			case 241: return "invalid OptionStatement";
+			case 242: return "invalid Identifier";
+			case 243: return "invalid IdentifierForFieldDeclaration";
+			case 244: return "invalid TypeName";
+			case 245: return "invalid PrimitiveTypeName";
+			case 246: return "invalid QualifiedTypeName";
+			case 247: return "invalid OnOff";
+			case 248: return "invalid BinaryText";
+			case 249: return "invalid ImportsClause";
+			case 250: return "this symbol not expected in ImportsClause";
 
 			default: return "error " + errorNumber;
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Parser/VBParser.cs b/NRefactory/ICSharpCode.NRefactory.VB/Parser/VBParser.cs
index 07c67597c..c099d7981 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Parser/VBParser.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Parser/VBParser.cs
@@ -12,13 +12,12 @@ using ICSharpCode.NRefactory.VB.Visitors;
 
 namespace ICSharpCode.NRefactory.VB.Parser
 {
-	public partial class VBParser : IDisposable
+	internal partial class VBParser : IDisposable
 	{
 		VBLexer lexer;
-		Stack<INode> blockStack;
+		Stack<AstNode> stack;
 		CompilationUnit compilationUnit;
 		int errDist = MinErrDist;
-		bool parseMethodContents = true;
 		
 		const int    MinErrDist   = 2;
 		const string ErrMsgFormat = "-- line {0} col {1}: {2}";  // 0=line, 1=column, 2=text
@@ -28,25 +27,31 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			this.errors = lexer.Errors;
 			errors.SynErr = new ErrorCodeProc(SynErr);
 			this.lexer = (VBLexer)lexer;
-			this.blockStack = new Stack<INode>();
+			this.stack = new Stack<AstNode>();
 		}
 		
-		void BlockStart(INode block)
+		#region Infrastructure
+		void NodeStart(AstNode node)
 		{
-			blockStack.Push(block);
+			stack.Push(node);
 		}
 		
-		void BlockEnd()
+		void NodeEnd(AstNode currentNode, Role role)
 		{
-			blockStack.Pop();
+			AstNode node = stack.Pop();
+			Debug.Assert(currentNode == node);
+			stack.Peek().AddChildUntyped(node, role);
 		}
 		
-		void AddChild(INode childNode)
+		void AddTerminal(Role<VBTokenNode> role)
+		{
+			stack.Peek().AddChild(new VBTokenNode(t.Location, t.EndLocation), role);
+		}
+		
+		void AddChild<T>(T childNode, Role<T> role) where T : AstNode
 		{
 			if (childNode != null) {
-				INode parent = (INode)blockStack.Peek();
-				parent.Children.Add(childNode);
-				childNode.Parent = parent;
+				stack.Peek().AddChild(childNode, role);
 			}
 		}
 		
@@ -59,6 +64,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 				return lexer.Token;
 			}
 		}
+		
 		Token la
 		{
 			[System.Diagnostics.DebuggerStepThrough]
@@ -67,7 +73,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			}
 		}
 
-		Token Peek (int n)
+		Token Peek(int n)
 		{
 			lexer.StartPeek();
 			Token x = la;
@@ -85,78 +91,87 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			}
 			errDist = 0;
 		}
-
+		#endregion
+		
+		#region Parse
 		public void Parse()
 		{
 			ParseRoot();
-			compilationUnit.AcceptVisitor(new SetParentVisitor(), null);
 		}
 		
-		public TypeReference ParseTypeReference ()
+		public AstType ParseAstType()
 		{
 			// TODO
 			return null;
 		}
 		
-		public Expression ParseExpression()
-		{
-			lexer.SetInitialContext(SnippetType.Expression);
-			lexer.NextToken();
-			Location startLocation = la.Location;
-			Expression expr;
-			Expr(out expr);
-			while (la.kind == Tokens.EOL) lexer.NextToken();
-			if (expr != null) {
-				expr.StartLocation = startLocation;
-				expr.EndLocation = t.EndLocation;
-				expr.AcceptVisitor(new SetParentVisitor(), null);
-			}
-			Expect(Tokens.EOF);
-			return expr;
-		}
+//		public Expression ParseExpression()
+//		{
+//			lexer.SetInitialContext(SnippetType.Expression);
+//			lexer.NextToken();
+//			Location startLocation = la.Location;
+//			Expression expr;
+//			Expr(out expr);
+//			while (la.kind == Tokens.EOL) lexer.NextToken();
+//			if (expr != null) {
+//				expr.StartLocation = startLocation;
+//				expr.EndLocation = t.EndLocation;
+//				expr.AcceptVisitor(new SetParentVisitor(), null);
+//			}
+//			Expect(Tokens.EOF);
+//			return expr;
+//		}
+		
+//		public BlockStatement ParseBlock()
+//		{
+//			lexer.NextToken();
+//			compilationUnit = new CompilationUnit();
+//
+//			Location startLocation = la.Location;
+//			Statement st;
+//			Block(out st);
+//			if (st != null) {
+//				st.StartLocation = startLocation;
+//				if (t != null)
+//					st.EndLocation = t.EndLocation;
+//				else
+//					st.EndLocation = la.Location;
+//				st.AcceptVisitor(new SetParentVisitor(), null);
+//			}
+//			Expect(Tokens.EOF);
+//			return st as BlockStatement;
+//		}
+		
+//		public List<AstNode> ParseTypeMembers()
+//		{
+//			lexer.NextToken();
+//			TypeDeclaration newType = new TypeDeclaration(Modifiers.None, null);
+//			BlockStart(newType);
+//			ClassBody(newType);
+//			BlockEnd();
+//			Expect(Tokens.EOF);
+//			newType.AcceptVisitor(new SetParentVisitor(), null);
+//			return newType.Children;
+//		}
+		#endregion
 		
-		public BlockStatement ParseBlock()
+		#region Conflict Resolvers
+		bool IsAliasImportsClause()
 		{
-			lexer.NextToken();
-			compilationUnit = new CompilationUnit();
-			
-			Location startLocation = la.Location;
-			Statement st;
-			Block(out st);
-			if (st != null) {
-				st.StartLocation = startLocation;
-				if (t != null)
-					st.EndLocation = t.EndLocation;
-				else
-					st.EndLocation = la.Location;
-				st.AcceptVisitor(new SetParentVisitor(), null);
-			}
-			Expect(Tokens.EOF);
-			return st as BlockStatement;
+			return IsIdentifierToken(la) && Peek(1).Kind == Tokens.Assign;
 		}
 		
-		public List<INode> ParseTypeMembers()
+		static bool IsIdentifierToken(Token tk)
 		{
-			lexer.NextToken();
-			TypeDeclaration newType = new TypeDeclaration(Modifiers.None, null);
-			BlockStart(newType);
-			ClassBody(newType);
-			BlockEnd();
-			Expect(Tokens.EOF);
-			newType.AcceptVisitor(new SetParentVisitor(), null);
-			return newType.Children;
+			return Tokens.IdentifierTokens[tk.kind] || tk.kind == Tokens.Identifier;
 		}
-
+		#endregion
+		
 		/* True, if "." is followed by an ident */
 		bool DotAndIdentOrKw () {
 			int peek = Peek(1).kind;
 			return la.kind == Tokens.Dot && (peek == Tokens.Identifier || peek >= Tokens.AddHandler);
 		}
-
-		static bool IsIdentifierToken(Token tk)
-		{
-			return Tokens.IdentifierTokens[tk.kind] || tk.kind == Tokens.Identifier;
-		}
 		
 		bool IsIdentifiedExpressionRange()
 		{
@@ -331,39 +346,29 @@ namespace ICSharpCode.NRefactory.VB.Parser
 			return la.kind == Tokens.Colon && Peek(1).kind == Tokens.EOL;
 		}
 
-		static bool IsMustOverride(ModifierList m)
+		static bool IsMustOverride(AttributedNode node)
 		{
-			return m.Contains(Modifiers.Abstract);
+			return node.Modifiers.HasFlag(Modifiers.MustOverride);
 		}
 
 		/* Writes the type name represented through the expression into the string builder. */
 		/* Returns true when the expression was converted successfully, returns false when */
 		/* There was an unknown expression (e.g. TypeReferenceExpression) in it */
-		bool WriteFullTypeName(StringBuilder b, Expression expr)
-		{
-			MemberReferenceExpression fre = expr as MemberReferenceExpression;
-			if (fre != null) {
-				bool result = WriteFullTypeName(b, fre.TargetObject);
-				if (b.Length > 0) b.Append('.');
-				b.Append(fre.MemberName);
-				return result;
-			} else if (expr is IdentifierExpression) {
-				b.Append(((IdentifierExpression)expr).Identifier);
-				return true;
-			} else {
-				return false;
-			}
-		}
-
-		/*
-		True, if lookahead is a local attribute target specifier,
-		i.e. one of "event", "return", "field", "method",
-		"module", "param", "property", or "type"
-		 */
-		bool IsLocalAttrTarget() {
-			// TODO
-			return false;
-		}
+//		bool WriteFullTypeName(StringBuilder b, Expression expr)
+//		{
+//			MemberReferenceExpression fre = expr as MemberReferenceExpression;
+//			if (fre != null) {
+//				bool result = WriteFullTypeName(b, fre.TargetObject);
+//				if (b.Length > 0) b.Append('.');
+//				b.Append(fre.MemberName);
+//				return result;
+//			} else if (expr is SimpleNameExpression) {
+//				b.Append(((SimpleNameExpression)expr).Identifier);
+//				return true;
+//			} else {
+//				return false;
+//			}
+//		}
 		
 		void EnsureIsZero(Expression expr)
 		{
@@ -371,31 +376,7 @@ namespace ICSharpCode.NRefactory.VB.Parser
 				Error("lower bound of array must be zero");
 		}
 		
-		/// <summary>
-		/// Adds a child item to a collection stored in the parent node.
-		/// Also set's the item's parent to <paramref name="parent"/>.
-		/// Does nothing if item is null.
-		/// </summary>
-		static void SafeAdd<T>(INode parent, List<T> list, T item) where T : class, INode
-		{
-			Debug.Assert(parent != null);
-			Debug.Assert((parent is INullable) ? !(parent as INullable).IsNull : true);
-			if (item != null) {
-				list.Add(item);
-				item.Parent = parent;
-			}
-		}
-		
-
-		
-		public bool ParseMethodBodies {
-			get {
-				return parseMethodContents;
-			}
-			set {
-				parseMethodContents = value;
-			}
-		}
+		public bool ParseMethodBodies { get; set; }
 		
 		public VBLexer Lexer {
 			get {
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Parser/vb.atg b/NRefactory/ICSharpCode.NRefactory.VB/Parser/vb.atg
index fbaf98990..f6787ab95 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Parser/vb.atg
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Parser/vb.atg
@@ -7,10 +7,11 @@ using System.Text;
 using ICSharpCode.NRefactory.VB.Ast;
 using ICSharpCode.NRefactory.VB.Parser;
 using ASTAttribute = ICSharpCode.NRefactory.VB.Ast.Attribute;
+using Roles = ICSharpCode.NRefactory.VB.AstNode.Roles;
 
 COMPILER VB
 
-/* START AUTOGENERATED TOKENS SECTION */
+#region AUTOGENERATED TOKENS SECTION
 TOKENS
 	/* ----- terminal classes ----- */
 	/* EOF is 0 */
@@ -23,16 +24,16 @@ TOKENS
 	LiteralSingle
 	LiteralDecimal
 	LiteralDate
-	XmlOpenTag
-	XmlCloseTag
-	XmlStartInlineVB
-	XmlEndInlineVB
-	XmlCloseTagEmptyElement
-	XmlOpenEndTag
-	XmlContent
-	XmlComment
-	XmlCData
-	XmlProcessingInstruction
+	XmlOpenTag					// <
+	XmlCloseTag				// >
+	XmlStartInlineVB			// <%=
+	XmlEndInlineVB				// %>
+	XmlCloseTagEmptyElement	// />
+	XmlOpenEndTag				// </
+	XmlContent					// ...
+	XmlComment					// <!-- ... -->
+	XmlCData					// <![CDATA[...]]>
+	XmlProcessingInstruction	
 
 	/* ----- special character ----- */
 	"="
@@ -255,3453 +256,35 @@ TOKENS
 	"WriteOnly"
 	"Xor"
 	"GetXmlNamespace"
-/* END AUTOGENERATED TOKENS SECTION */
+#endregion
 
 PRODUCTIONS
 
-VB
-	(.
-		lexer.NextToken(); // get the first token
-		compilationUnit = new CompilationUnit();
-		BlockStart(compilationUnit);
-	.)
-=
-	{ EndOfStmt }
-	{ OptionStmt { EndOfStmt } }
-	{ ImportsStmt { EndOfStmt } }
-	{ IF (IsGlobalAttrTarget()) GlobalAttributeSection { EndOfStmt } }
-	{ NamespaceMemberDecl { EndOfStmt } }
-.
-
-OptionStmt (. INode node = null; bool val = true; .) =
-	"Option" (. Location startPos = t.Location; .)
-	(
-		"Explicit" [ OptionValue<ref val> ]
-		(. node = new OptionDeclaration(OptionType.Explicit, val); .)
-		|
-		"Strict" [ OptionValue<ref val> ]
-		(. node = new OptionDeclaration(OptionType.Strict, val); .)
-		|
-		"Compare" ( "Binary" (. node = new OptionDeclaration(OptionType.CompareBinary, val); .)
-				  | "Text" (. node = new OptionDeclaration(OptionType.CompareText, val); .)
-				  )
-		|
-		"Infer" [ OptionValue<ref val> ]
-		(. node = new OptionDeclaration(OptionType.Infer, val); .)
-	)
-	EndOfStmt
-	(.
-		if (node != null) {
-			node.StartLocation = startPos;
-			node.EndLocation   = t.Location;
-			AddChild(node);
-		}
-	.)
-.
-
-OptionValue<ref bool val> =
-	(
-		"On" (. val = true; .)
-	|
-		"Off" (. val = false; .)
-	)
-	.
-
-EndOfStmt =
-	SYNC ( EOL | ":" )
-.
-
-ImportsStmt
-	(.List<Using> usings = new List<Using>();
-	.) =
-	"Imports"
-	(.
-		Location startPos = t.Location;
-		Using u;
-	.)
-	ImportClause<out u> (. if (u != null) { usings.Add(u); } .)
-	{
-		"," ImportClause<out u> (. if (u != null) { usings.Add(u); } .)
-	}
-	EndOfStmt
-	(.
-		UsingDeclaration usingDeclaration = new UsingDeclaration(usings);
-		usingDeclaration.StartLocation = startPos;
-		usingDeclaration.EndLocation   = t.Location;
-		AddChild(usingDeclaration);
-	.)
-	.
-
-ImportClause<out Using u>
-	(.
-		string qualident  = null;
-		TypeReference aliasedType = null;
-		u = null;
-	.) =
-	(
-		Qualident<out qualident>
-		[ "=" TypeName<out aliasedType> ]
-		(.
-			if (qualident != null && qualident.Length > 0) {
-				if (aliasedType != null) {
-					u = new Using(qualident, aliasedType);
-				} else {
-					u = new Using(qualident);
-				}
-			}
-		.)
-	) | ( (. string prefix = null; .)
-		XmlOpenTag Identifier (. prefix = t.val; .) "=" LiteralString (. u = new Using(t.literalValue as string, prefix); .) XmlCloseTag
-	)
-	.
-
-/* 6.4.2 */
-NamespaceMemberDecl
-	(.
-		ModifierList m = new ModifierList();
-		AttributeSection section;
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		string qualident;
-	.) =
-	("Namespace"
-	(.
-		Location startPos = t.Location;
-	.)
-	Qualident<out qualident>
-	(.
-		INode node =  new NamespaceDeclaration(qualident);
-		node.StartLocation = startPos;
-		AddChild(node);
-		BlockStart(node);
-	.)
-	EndOfStmt
-	NamespaceBody
-	(.
-		node.EndLocation = t.Location;
-		BlockEnd();
-	.)
-	) | (
-	{ AttributeSection<out section> (. attributes.Add(section); .) }
-	{ TypeModifier<m> } NonModuleDeclaration<m, attributes> )
-	.
-
-/* 4.9.1 */
-TypeParameterList<.List<TemplateDefinition> templates.>
-(.
-	TemplateDefinition template;
-.)
-=
-	[
-		IF (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)
-		"(" "Of" TypeParameter<out template>
-		(.
-			if (template != null) templates.Add(template);
-		.)
-		{
-			"," TypeParameter<out template>
-			(.
-				if (template != null) templates.Add(template);
-			.)
-		}
-		")"
-	]
-.
-
-/* 4.9.1 */
-TypeParameter<out TemplateDefinition template>
-	(. VarianceModifier modifier = VarianceModifier.Invariant; Location startLocation = la.Location; .)
-=
-	(
-		[ "In" (. modifier = VarianceModifier.Contravariant; .)
-		| IF (la.kind == Tokens.Out && IsIdentifierToken(Peek(1))) "Out" (. modifier = VarianceModifier.Covariant; .)
-		]
-		Identifier (. template = new TemplateDefinition(t.val, null) { VarianceModifier = modifier }; .)
-		[TypeParameterConstraints<template>]
-	)
-	(.
-		if (template != null) {
-			template.StartLocation = startLocation;
-			template.EndLocation = t.EndLocation;
-		}
-	.)
-.
-
-/* 4.9.2 */
-TypeParameterConstraints<TemplateDefinition template>
-(.
-	TypeReference constraint;
-.)
-=
-	"As"
-	(
-		"{"
-		TypeParameterConstraint<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
-		{
-			","
-			TypeParameterConstraint<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
-		}
-		"}"
-		| TypeParameterConstraint<out constraint> (. if (constraint != null) { template.Bases.Add(constraint); } .)
-	)
-.
-
-TypeParameterConstraint<out TypeReference constraint>
-	(. constraint = null; Location startLocation = la.Location; .)
-=
-	"Class"		(. constraint = TypeReference.ClassConstraint; .)
-	| "Structure"	(. constraint = TypeReference.StructConstraint; .)
-	| "New"		(. constraint = TypeReference.NewConstraint; .)
-	| TypeName<out constraint>
-.
-
-/* 6.4.2 */
-NonModuleDeclaration<.ModifierList m, List<AttributeSection> attributes.>
-			(.
-				TypeReference typeRef = null;
-				List<TypeReference> baseInterfaces = null;
-			.) =
-	(. m.Check(Modifiers.Classes); .)
-	/* Spec, 7.5 */
-	"Class"
-					(. TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-						newType.StartLocation = t.Location;
-						AddChild(newType);
-						BlockStart(newType);
-						
-						newType.Type       = ClassType.Class;
-					.)
-	Identifier			 (. newType.Name = t.val; .) 
-	TypeParameterList<newType.Templates>
-	EndOfStmt
-	(. newType.BodyStartLocation = t.Location; .)
-	[ ClassBaseType<out typeRef> (. SafeAdd(newType, newType.BaseTypes, typeRef); .) ]
-	{ TypeImplementsClause<out baseInterfaces> (. newType.BaseTypes.AddRange(baseInterfaces); .) }
-	ClassBody<newType>
-	"End" "Class" (. newType.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	(.
-		BlockEnd();
-	.)
-	| "Module"
-		(.
-			m.Check(Modifiers.VBModules);
-			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-			AddChild(newType);
-			BlockStart(newType);
-			newType.StartLocation = m.GetDeclarationLocation(t.Location);
-			newType.Type = ClassType.Module;
-		.)
-	Identifier			 (. newType.Name = t.val; .)
-	EndOfStmt
-	(. newType.BodyStartLocation = t.Location; .)
-	ModuleBody<newType>
-	(.
-		BlockEnd();
-	.)
-	| "Structure"
-		(.
-			m.Check(Modifiers.VBStructures);
-			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-			AddChild(newType);
-			BlockStart(newType);
-			newType.StartLocation = m.GetDeclarationLocation(t.Location);
-			newType.Type = ClassType.Struct;
-		.)
-	Identifier			 (. newType.Name = t.val; .) 
-	TypeParameterList<newType.Templates>
-	EndOfStmt
-	(. newType.BodyStartLocation = t.Location; .)
-	{ TypeImplementsClause<out baseInterfaces> (. newType.BaseTypes.AddRange(baseInterfaces);.) }
-	StructureBody<newType>
-	(.
-		BlockEnd();
-	.)
-	| /* 7.4 */
-	"Enum"
-		(.
-			m.Check(Modifiers.VBEnums);
-			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-			newType.StartLocation = m.GetDeclarationLocation(t.Location);
-			AddChild(newType);
-			BlockStart(newType);
-			
-			newType.Type = ClassType.Enum;
-		.)
-	Identifier			 (. newType.Name = t.val; .) 
-	[ "As" NonArrayTypeName<out typeRef, false> (. SafeAdd(newType, newType.BaseTypes, typeRef); .) ]
-	EndOfStmt
-	(. newType.BodyStartLocation = t.Location; .)
-	EnumBody<newType>
-	(.
-		BlockEnd();
-	.)
-	| /* 7.8 */
-	"Interface"
-		(.
-			m.Check(Modifiers.VBInterfacs);
-			TypeDeclaration newType = new TypeDeclaration(m.Modifier, attributes);
-			newType.StartLocation = m.GetDeclarationLocation(t.Location);
-			AddChild(newType);
-			BlockStart(newType);
-			newType.Type = ClassType.Interface;
-		.)
-	Identifier			 (. newType.Name = t.val; .) 
-	TypeParameterList<newType.Templates>
-	EndOfStmt
-	(. newType.BodyStartLocation = t.Location; .)
-	{ InterfaceBase<out baseInterfaces> (. newType.BaseTypes.AddRange(baseInterfaces); .) }
-	InterfaceBody<newType>
-	(.
-		BlockEnd();
-	.)
-	| /* 7.10 */
-	"Delegate"
-	(.
-		m.Check(Modifiers.VBDelegates);
-		DelegateDeclaration delegateDeclr = new DelegateDeclaration(m.Modifier, attributes);
-		delegateDeclr.ReturnType = new TypeReference("System.Void", true);
-		delegateDeclr.StartLocation = m.GetDeclarationLocation(t.Location);
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-	.)
-	(
-		"Sub" Identifier (. delegateDeclr.Name = t.val; .)
-		TypeParameterList<delegateDeclr.Templates>
-		[ "(" [ FormalParameterList<p> ] ")" (. delegateDeclr.Parameters = p; .) ]
-		|
-		"Function" Identifier (. delegateDeclr.Name = t.val; .)
-		TypeParameterList<delegateDeclr.Templates>
-		[ "(" [ FormalParameterList<p> ] ")" (. delegateDeclr.Parameters = p; .) ]
-		[ "As" (. TypeReference type; .) TypeName<out type> (. delegateDeclr.ReturnType = type; .)]
-	)
-	(. 		delegateDeclr.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	(.
-		AddChild(delegateDeclr);
-	.)
-	.
-
-NamespaceBody =
-	{ EndOfStmt } /* allow empty lines at begin of body */
-	{
-		NamespaceMemberDecl
-		{ EndOfStmt } /* allow empty lines in body */
-	}
-	"End" "Namespace"
-	EndOfStmt
-	.
-
-ClassBody<TypeDeclaration newType>
-	(. AttributeSection section; .) =
-	{ EndOfStmt } /* allow empty lines at begin of body */
-	{
-		(.List<AttributeSection> attributes = new List<AttributeSection>();
-			ModifierList m = new ModifierList();
-		.)
-		{ AttributeSection<out section> (. attributes.Add(section); .) }
-		{ MemberModifier<m> }
-		ClassMemberDecl<m, attributes>
-		{ EndOfStmt } /* allow empty lines in body */
-	}
-	.
-
-StructureBody<TypeDeclaration newType>
-	(. AttributeSection section; .) =
-	{ EndOfStmt } /* allow empty lines at begin of body */
-	{
-		(.List<AttributeSection> attributes = new List<AttributeSection>();
-			ModifierList m = new ModifierList();
-		.)
-		{ AttributeSection<out section> (. attributes.Add(section); .) }
-		{ MemberModifier<m> }
-		StructureMemberDecl<m, attributes>
-		{ EndOfStmt } /* allow empty lines in body */
-	}
-	"End" "Structure" (. newType.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	.
-
-/* 7.7.1 */
-ModuleBody<TypeDeclaration newType>
-	(. AttributeSection section; .) =
-	{ EndOfStmt } /* allow empty lines at begin of body */
-	{
-		(.List<AttributeSection> attributes = new List<AttributeSection>();
-			ModifierList m = new ModifierList();
-		.)
-		{ AttributeSection<out section> (. attributes.Add(section); .) }
-		{ MemberModifier<m> }
-		ClassMemberDecl<m, attributes>
-		{ EndOfStmt } /* allow empty lines in body */
-	}
-	"End" "Module" (. newType.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	.
-
-EnumBody<TypeDeclaration newType>
-	(. FieldDeclaration f; .) =
-	{ EndOfStmt } /* allow empty lines at begin of body */
-	{
-		EnumMemberDecl<out f>
-		(.
-			AddChild(f);
-		.)
-		{ EndOfStmt } /* allow empty lines in body */
-	}
-	"End" "Enum" (. newType.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	.
-
-InterfaceBody<TypeDeclaration newType> =
-	{ EndOfStmt } /* allow empty lines at begin of body */
-	{
-		InterfaceMemberDecl
-		{ EndOfStmt } /* allow empty lines in body */
-	}
-	"End" "Interface" (. newType.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	.
-
-/* The information provided in the spec about */
-/* interface declarations is wrong */
-InterfaceMemberDecl
-	(.
-		TypeReference type =null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		List<TemplateDefinition> templates = new List<TemplateDefinition>();
-		AttributeSection section, returnTypeAttributeSection = null;
-		ModifierList mod = new ModifierList();
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		string name;
-	.) =
-	{ AttributeSection<out section>			(. attributes.Add(section); .) }
-	/* this is different to c#: not only the Shadows modifier is allowed, */
-	/*  also member modifiers like overloads etc. */
-	{ MemberModifier<mod> }
-	(
-		"Event"
-		(.
-			mod.Check(Modifiers.VBInterfaceEvents);
-			Location startLocation = t.Location;
-		.)
-		Identifier (. name = t.val; .)
-		[ "(" [ FormalParameterList<p> ] ")" ]
-		[ "As" TypeName<out type> ]
-		EndOfStmt
-		(.
-			EventDeclaration ed = new EventDeclaration {
-				Name = name, TypeReference = type, Modifier = mod.Modifier,
-				Parameters = p, Attributes = attributes,
-				StartLocation = startLocation, EndLocation = t.EndLocation
-			};
-			AddChild(ed);
-		.)
-		|
-		"Sub"
-		(.
-			Location startLocation =  t.Location;
-			mod.Check(Modifiers.VBInterfaceMethods);
-		.)
-		Identifier (. name = t.val; .)
-		TypeParameterList<templates>
-		[ "(" [ FormalParameterList<p> ] ")" ]
-		EndOfStmt
-		(.
-			MethodDeclaration md = new MethodDeclaration {
-				Name = name, 
-				Modifier = mod.Modifier, 
-				Parameters = p,
-				Attributes = attributes,
-				TypeReference = new TypeReference("System.Void", true),
-				StartLocation = startLocation,
-				EndLocation = t.EndLocation,
-				Templates = templates
-			};
-			AddChild(md);
-		.)
-		|
-		"Function"
-		(.
-			mod.Check(Modifiers.VBInterfaceMethods);
-			Location startLocation = t.Location;
-		.)
-		Identifier (. name = t.val; .)
-		TypeParameterList<templates>
-		[ "(" [ FormalParameterList<p> ] ")" ]
-		[ "As" { AttributeSection<out returnTypeAttributeSection> } TypeName<out type> ]
-		(.
-			if(type == null) {
-				type = new TypeReference("System.Object", true);
-			}
-			MethodDeclaration md = new MethodDeclaration {
-				Name = name, Modifier = mod.Modifier, 
-				TypeReference = type, Parameters = p, Attributes = attributes
-			};
-			if (returnTypeAttributeSection != null) {
-				returnTypeAttributeSection.AttributeTarget = "return";
-				md.Attributes.Add(returnTypeAttributeSection);
-			}
-			md.StartLocation = startLocation;
-			md.EndLocation = t.EndLocation;
-			md.Templates = templates;
-			AddChild(md);
-		.)
-		EndOfStmt
-		|
-		"Property"
-		(.
-			Location startLocation = t.Location;
-			mod.Check(Modifiers.VBInterfaceProperties);
-		.)
-		Identifier	(. name = t.val;  .)
-		[ "(" [ FormalParameterList<p> ] ")" ]
-		[ "As" TypeName<out type> ]
-		(.
-			if(type == null) {
-				type = new TypeReference("System.Object", true);
-			}
-		.)
-		EndOfStmt
-		(.
-			PropertyDeclaration pd = new PropertyDeclaration(name, type, mod.Modifier, attributes);
-			pd.Parameters = p;
-			pd.EndLocation = t.EndLocation;
-			pd.StartLocation = startLocation;
-			AddChild(pd);
-		.)
-	)
-	| /* inner type declarations */
-	NonModuleDeclaration<mod, attributes>
-	.
-
-/* 7.4.1 */
-EnumMemberDecl<out FieldDeclaration f>
-	(.
-		Expression expr = null;List<AttributeSection> attributes = new List<AttributeSection>();
-		AttributeSection section = null;
-		VariableDeclaration varDecl = null;
-	.) =
-	{ AttributeSection<out section> (. attributes.Add(section); .) }
-	Identifier
-	(.
-		f = new FieldDeclaration(attributes);
-		varDecl = new VariableDeclaration(t.val);
-		f.Fields.Add(varDecl);
-		f.StartLocation = varDecl.StartLocation = t.Location;
-	.)
-	[ "=" Expr<out expr> (. varDecl.Initializer = expr; .) ]
-	(. f.EndLocation = varDecl.EndLocation = t.EndLocation; .)
-	EndOfStmt
-.
-
-ClassMemberDecl<.ModifierList m, List<AttributeSection> attributes.> =
-	StructureMemberDecl<m, attributes>
-	.
-
-ClassBaseType<out TypeReference typeRef>
-(.
-	typeRef = null;
-.) =
-	"Inherits"
-	TypeName<out typeRef>
-	EndOfStmt
-.
-
-/* 7.6.1 */
-StructureMemberDecl<.ModifierList m, List<AttributeSection> attributes.>
-	(.
-		TypeReference type = null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		Statement stmt = null;
-		List<VariableDeclaration> variableDeclarators = new List<VariableDeclaration>();
-		List<TemplateDefinition> templates = new List<TemplateDefinition>();
-	.)
-=
-	NonModuleDeclaration<m, attributes>
-| /* 9.2.1 */
-	"Sub"
-	(.
-		Location startPos = t.Location;
-	.)
-	(
-		(.
-			string name = String.Empty;
-			MethodDeclaration methodDeclaration; List<string> handlesClause = null;
-			List<InterfaceImplementation> implementsClause = null;
-		.)
-		Identifier
-		(.
-			name = t.val;
-			m.Check(Modifiers.VBMethods);
-		.)
-		TypeParameterList<templates>
-		[ "(" [ FormalParameterList<p> ] ")" ]
-		[
-			(
-				ImplementsClause<out implementsClause>
-				|
-				HandlesClause<out handlesClause>
-			)
-		]
-		(. Location endLocation = t.EndLocation; .)
-		(
-			/* abstract methods without a body */
-			IF(IsMustOverride(m))
-			EndOfStmt
-			(.
-				methodDeclaration = new MethodDeclaration {
-					Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
-					StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
-					TypeReference = new TypeReference("System.Void", true),
-					Templates = templates,
-					HandlesClause = handlesClause,
-					InterfaceImplementations = implementsClause
-				};
-				AddChild(methodDeclaration);
-			.)
-		|
-			EOL
-			(.
-				methodDeclaration = new MethodDeclaration {
-					Name = name, Modifier = m.Modifier, Parameters = p, Attributes = attributes,
-					StartLocation = m.GetDeclarationLocation(startPos), EndLocation = endLocation,
-					TypeReference = new TypeReference("System.Void", true),
-					Templates = templates,
-					HandlesClause = handlesClause,
-					InterfaceImplementations = implementsClause
-				};
-				AddChild(methodDeclaration);
-			.)
-			
-			(. if (ParseMethodBodies) { .)
-				Block<out stmt>
-				"End" "Sub"
-			(. } else {
-				// don't parse method body
-				lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
-			   }
-			.)
-			
-			(. methodDeclaration.Body  = (BlockStatement)stmt; .)
-			(. methodDeclaration.Body.EndLocation = t.EndLocation; .)
-			EndOfStmt
-		)
-		/* 9.3 */
-		| "New" [ "(" [ FormalParameterList<p> ] ")" ]
-		(. m.Check(Modifiers.Constructors); .)
-		(. Location constructorEndLocation = t.EndLocation; .)
-		EOL
-		
-		(. if (ParseMethodBodies) { .)
-			Block<out stmt>
-			"End" "Sub"
-		(. } else {
-			// don't parse method body
-			lexer.SkipCurrentBlock(Tokens.Sub); stmt = new BlockStatement();
-		   }
-		.)
-		
-		(. Location endLocation = t.EndLocation; .)
-		EndOfStmt
-		(.
-			ConstructorDeclaration cd = new ConstructorDeclaration("New", m.Modifier, p, attributes);
-			cd.StartLocation = m.GetDeclarationLocation(startPos);
-			cd.EndLocation   = constructorEndLocation;
-			cd.Body = (BlockStatement)stmt;
-			cd.Body.EndLocation   = endLocation;
-			AddChild(cd);
-		.)
-	)
-|
-	/* 9.2.1 */
-	"Function"
-	(.
-		m.Check(Modifiers.VBMethods);
-		string name = String.Empty;
-		Location startPos = t.Location;
-		MethodDeclaration methodDeclaration;List<string> handlesClause = null;
-		List<InterfaceImplementation> implementsClause = null;
-		AttributeSection returnTypeAttributeSection = null;
-	.)
-	Identifier			(. name = t.val; .)
-	TypeParameterList<templates>
-	[ "("	[ FormalParameterList<p> ] ")" ]
-	["As"  {
-				AttributeSection<out returnTypeAttributeSection>
-				(.
-					if (returnTypeAttributeSection != null) {
-						returnTypeAttributeSection.AttributeTarget = "return";
-						attributes.Add(returnTypeAttributeSection);
-					}
-				.)
-			}
-	TypeName<out type> ]
-	(.
-		if(type == null) {
-			type = new TypeReference("System.Object", true);
-		}
-	.)
-	[
-		(
-			ImplementsClause<out implementsClause>
-			|
-			HandlesClause<out handlesClause>
-		)
-	]
-	(. Location endLocation = t.EndLocation; .)
-	(
-		/* abstract methods without a body */
-		IF(IsMustOverride(m))
-		EndOfStmt
-			(.
-				methodDeclaration = new MethodDeclaration {
-					Name = name, Modifier = m.Modifier, TypeReference = type,
-					Parameters = p, Attributes = attributes,
-					StartLocation = m.GetDeclarationLocation(startPos),
-					EndLocation   = endLocation,
-					HandlesClause = handlesClause,
-					Templates     = templates,
-					InterfaceImplementations = implementsClause
-				};
-				
-				AddChild(methodDeclaration);
-			.)
-		|
-			EOL
-			(.
-				methodDeclaration = new MethodDeclaration {
-					Name = name, Modifier = m.Modifier, TypeReference = type,
-					Parameters = p, Attributes = attributes,
-					StartLocation = m.GetDeclarationLocation(startPos),
-					EndLocation   = endLocation,
-					Templates     = templates,
-					HandlesClause = handlesClause,
-					InterfaceImplementations = implementsClause
-				};
-				
-				AddChild(methodDeclaration);
-			
-				if (ParseMethodBodies) { .)
-					Block<out stmt>
-					"End" "Function"
-			(.	} else {
-					// don't parse method body
-					lexer.SkipCurrentBlock(Tokens.Function); stmt = new BlockStatement();
-				}
-				methodDeclaration.Body = (BlockStatement)stmt;
-				methodDeclaration.Body.StartLocation = methodDeclaration.EndLocation;
-				methodDeclaration.Body.EndLocation   = t.EndLocation;
-			.)
-			EndOfStmt
-	)
-|
-	/* 9.2.2. */
-	"Declare"
-	(.
-		m.Check(Modifiers.VBExternalMethods);
-		Location startPos = t.Location;
-		CharsetModifier charsetModifer = CharsetModifier.None;
-		string library = String.Empty;
-		string alias = null;
-		string name = String.Empty;
-	.)
-	[Charset<out charsetModifer> ]
-	(
-			"Sub"
-			Identifier				(. name = t.val; .)
-			"Lib" LiteralString		(. library = t.literalValue as string; .)
-			["Alias" LiteralString	(. alias = t.literalValue as string; .)]
-			[ "("	[ FormalParameterList<p> ] ")" ]
-			EndOfStmt
-			(.
-				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, null, p, attributes, library, alias, charsetModifer);
-				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
-				declareDeclaration.EndLocation   = t.EndLocation;
-				AddChild(declareDeclaration);
-			.)
-		|
-			"Function" 
-			Identifier					(. name = t.val; .)
-			"Lib" LiteralString		(. library = t.literalValue as string; .)
-			["Alias" LiteralString	(. alias = t.literalValue as string; .)]
-			[ "("	[ FormalParameterList<p> ] ")" ]
-			["As" TypeName<out type> ]
-			EndOfStmt
-			(.
-				DeclareDeclaration declareDeclaration = new DeclareDeclaration(name, m.Modifier, type, p, attributes, library, alias, charsetModifer);
-				declareDeclaration.StartLocation = m.GetDeclarationLocation(startPos);
-				declareDeclaration.EndLocation   = t.EndLocation;
-				AddChild(declareDeclaration);
-			.)
-		)
-|
-	/* 9. 4 */
-	"Event"
-	(.
-		m.Check(Modifiers.VBEvents);
-		Location startPos = t.Location;
-		EventDeclaration eventDeclaration;
-		string name = String.Empty;
-		List<InterfaceImplementation> implementsClause = null;
-	.)
-	Identifier (. name= t.val; .)
-	(
-		"As" TypeName<out type>
-		|
-		[ "("	[ FormalParameterList<p> ] ")" ]
-	)
-	[ ImplementsClause<out implementsClause> ]
-	(.
-		eventDeclaration = new EventDeclaration {
-			Name = name, TypeReference = type, Modifier = m.Modifier, 
-			Parameters = p, Attributes = attributes, InterfaceImplementations = implementsClause,
-			StartLocation = m.GetDeclarationLocation(startPos),
-			EndLocation = t.EndLocation
-		};
-		AddChild(eventDeclaration);
-	.)
-	EndOfStmt
-| /* 9.6 */
-	(.
-		m.Check(Modifiers.Fields);
-		FieldDeclaration fd = new FieldDeclaration(attributes, null, m.Modifier);
-	.)
-	IdentifierForFieldDeclaration (. string name = t.val; .)
-	(. fd.StartLocation = m.GetDeclarationLocation(t.Location); .)
-	
-	VariableDeclaratorPartAfterIdentifier<variableDeclarators, name>
-	{ "," VariableDeclarator<variableDeclarators> }
-	EndOfStmt
-	(.
-		fd.EndLocation = t.EndLocation;
-		fd.Fields = variableDeclarators;
-		AddChild(fd);
-	.)
-	| /* 9.4 */
-	(. m.Check(Modifiers.Fields); .)
-	"Const" (.  m.Add(Modifiers.Const, t.Location);  .)
-	(.
-		FieldDeclaration fd = new FieldDeclaration(attributes, type, m.Modifier);
-		fd.StartLocation = m.GetDeclarationLocation(t.Location);
-		List<VariableDeclaration> constantDeclarators = new List<VariableDeclaration>();
-	.)
-	ConstantDeclarator<constantDeclarators>
-	{ "," ConstantDeclarator<constantDeclarators> }
-	(.
-		fd.Fields = constantDeclarators;
-		fd.EndLocation = t.Location;
-	.)
-	EndOfStmt
-	(.
-		fd.EndLocation = t.EndLocation;
-		AddChild(fd);
-	.)
-| /* 9.7 */
-	"Property"
-	(.
-		m.Check(Modifiers.VBProperties);
-		Location startPos = t.Location;
-		List<InterfaceImplementation> implementsClause = null;
-		AttributeSection returnTypeAttributeSection = null;
-		Expression initializer = null;
-	.)
-	Identifier (. string propertyName = t.val; .)
-	[ "("	[ FormalParameterList<p> ] ")" ]
-	[
-		"As" {
-				AttributeSection<out returnTypeAttributeSection>
-				(.
-					if (returnTypeAttributeSection != null) {
-						returnTypeAttributeSection.AttributeTarget = "return";
-						attributes.Add(returnTypeAttributeSection);
-					}
-				.)
-		}
-		(
-			IF (IsNewExpression()) ObjectCreateExpression<out initializer>
-			(.
-				if (initializer is ObjectCreateExpression) {
-					type = ((ObjectCreateExpression)initializer).CreateType.Clone();
-				} else {
-					type = ((ArrayCreateExpression)initializer).CreateType.Clone();
-				}
-			.)
-		|
-			TypeName<out type>
-		)
-	]
-	[ "=" Expr<out initializer> ]
-	[ ImplementsClause<out implementsClause> ]
-	EndOfStmt
-	(
-	/* abstract properties without a body */
-	IF(IsMustOverride(m) || IsAutomaticProperty())
-		(.
-			PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
-			pDecl.StartLocation = m.GetDeclarationLocation(startPos);
-			pDecl.EndLocation   = t.Location;
-			pDecl.TypeReference = type;
-			pDecl.InterfaceImplementations = implementsClause;
-			pDecl.Parameters = p;
-			if (initializer != null)
-				pDecl.Initializer = initializer;
-			AddChild(pDecl);
-		.)
-	|
-		(.
-			PropertyDeclaration pDecl = new PropertyDeclaration(propertyName, type, m.Modifier, attributes);
-			pDecl.StartLocation = m.GetDeclarationLocation(startPos);
-			pDecl.EndLocation   = t.Location;
-			pDecl.BodyStart   = t.Location;
-			pDecl.TypeReference = type;
-			pDecl.InterfaceImplementations = implementsClause;
-			pDecl.Parameters = p;
-			PropertyGetRegion getRegion;
-			PropertySetRegion setRegion;
-		.)
-		AccessorDecls<out getRegion, out setRegion> 
-		"End" "Property"
-		EndOfStmt
-		(.
-			pDecl.GetRegion = getRegion;
-			pDecl.SetRegion = setRegion;
-			pDecl.BodyEnd = t.Location; // t = EndOfStmt; not "Property"
-			AddChild(pDecl);
-		.)
-	)
-|
-	"Custom" (. Location startPos = t.Location; .) "Event"
-	(.
-		m.Check(Modifiers.VBCustomEvents);
-		EventAddRemoveRegion eventAccessorDeclaration;
-		EventAddRegion addHandlerAccessorDeclaration = null;
-		EventRemoveRegion removeHandlerAccessorDeclaration = null;
-		EventRaiseRegion raiseEventAccessorDeclaration = null;
-		List<InterfaceImplementation> implementsClause = null;
-	.)
-	Identifier (. string customEventName = t.val; .)
-	"As" TypeName<out type>
-	[ ImplementsClause<out implementsClause> ]
-	EndOfStmt
-	{
-		EventAccessorDeclaration<out eventAccessorDeclaration>
-		(.
-			if(eventAccessorDeclaration is EventAddRegion)
-			{
-				addHandlerAccessorDeclaration = (EventAddRegion)eventAccessorDeclaration;
-			}
-			else if(eventAccessorDeclaration is EventRemoveRegion)
-			{
-				removeHandlerAccessorDeclaration = (EventRemoveRegion)eventAccessorDeclaration;
-			}
-			else if(eventAccessorDeclaration is EventRaiseRegion)
-			{
-				raiseEventAccessorDeclaration = (EventRaiseRegion)eventAccessorDeclaration;
-			}
-		.)
-	}
-	"End" "Event" EndOfStmt
-	(.
-		if(addHandlerAccessorDeclaration == null)
-		{
-			Error("Need to provide AddHandler accessor.");
-		}
-		
-		if(removeHandlerAccessorDeclaration == null)
-		{
-			Error("Need to provide RemoveHandler accessor.");
-		}
-		
-		if(raiseEventAccessorDeclaration == null)
-		{
-			Error("Need to provide RaiseEvent accessor.");
-		}
-	
-		EventDeclaration decl = new EventDeclaration {
-			TypeReference = type, Name = customEventName, Modifier = m.Modifier,
-			Attributes = attributes,
-			StartLocation = m.GetDeclarationLocation(startPos),
-			EndLocation = t.EndLocation,
-			AddRegion = addHandlerAccessorDeclaration,
-			RemoveRegion = removeHandlerAccessorDeclaration,
-			RaiseRegion = raiseEventAccessorDeclaration
-		};
-		AddChild(decl);
-	.)
-|   (. ConversionType opConversionType = ConversionType.None; .)
-	[ "Widening"		(. opConversionType = ConversionType.Implicit; .)
-	| "Narrowing"		(. opConversionType = ConversionType.Explicit;.) ]
-	"Operator"
-	(.
-		m.Check(Modifiers.VBOperators);
-		Location startPos = t.Location;
-		TypeReference returnType = NullTypeReference.Instance;
-		TypeReference operandType = NullTypeReference.Instance;
-		OverloadableOperatorType operatorType;
-		AttributeSection section;
-		ParameterDeclarationExpression param;
-		List<ParameterDeclarationExpression> parameters = new List<ParameterDeclarationExpression>();
-	.)
-	OverloadableOperator<out operatorType>
-	"("
-	FormalParameter<out param>
-	(. if (param != null) parameters.Add(param); .)
-	[
-		"," FormalParameter<out param>
-		(. if (param != null) parameters.Add(param); .)
-	]
-	")"
-	(. Location endPos = t.EndLocation; .)
-	[ "As" { AttributeSection<out section>
-			(. if (section != null) {
-					section.AttributeTarget = "return";
-					attributes.Add(section);
-		  } .)
-			} TypeName<out returnType> (. endPos = t.EndLocation; .) ]
-	EOL
-	Block<out stmt> "End" "Operator" EndOfStmt
-	(.
-		OperatorDeclaration operatorDeclaration = new OperatorDeclaration {
-			Modifier = m.Modifier,
-			Attributes = attributes,
-			Parameters = parameters,
-			TypeReference = returnType,
-			OverloadableOperator = operatorType,
-			ConversionType = opConversionType,
-			Body = (BlockStatement)stmt,
-			StartLocation = m.GetDeclarationLocation(startPos),
-			EndLocation = endPos
-		};
-		operatorDeclaration.Body.StartLocation = startPos;
-		operatorDeclaration.Body.EndLocation = t.Location;
-		AddChild(operatorDeclaration);
-	.)
-.
-
-OverloadableOperator<out OverloadableOperatorType operatorType>
-	(. operatorType = OverloadableOperatorType.None; .)
-	=
-	"+"			(. operatorType = OverloadableOperatorType.Add; .)
-	|
-	"-"			(. operatorType = OverloadableOperatorType.Subtract; .)
-	|
-	"*"			(. operatorType = OverloadableOperatorType.Multiply; .)
-	| 
-	"/"			(. operatorType = OverloadableOperatorType.Divide; .)
-	| 
-	"\\"		(. operatorType = OverloadableOperatorType.DivideInteger; .)
-	| 
-	"&"			(. operatorType = OverloadableOperatorType.Concat; .)
-	| 
-	"Like"		(. operatorType = OverloadableOperatorType.Like; .)
-	| 
-	"Mod"		(. operatorType = OverloadableOperatorType.Modulus; .)
-	| 
-	"And"		(. operatorType = OverloadableOperatorType.BitwiseAnd; .)
-	|
-	"Or"		(. operatorType = OverloadableOperatorType.BitwiseOr; .)
-	|
-	"Xor"		(. operatorType = OverloadableOperatorType.ExclusiveOr; .)
-	|
-	"^"			(. operatorType = OverloadableOperatorType.Power; .)
-	|
-	"<<"		(. operatorType = OverloadableOperatorType.ShiftLeft; .)
-	|
-	">>"		(. operatorType = OverloadableOperatorType.ShiftRight; .)
-	|
-	"="			(. operatorType = OverloadableOperatorType.Equality; .)
-	|
-	"<>"		(. operatorType = OverloadableOperatorType.InEquality; .)
-	|
-	"<"			(. operatorType = OverloadableOperatorType.LessThan; .)
-	|
-	"<="		(. operatorType = OverloadableOperatorType.LessThanOrEqual; .)
-	|
-	">"			(. operatorType = OverloadableOperatorType.GreaterThan; .)
-	|
-	">="		(. operatorType = OverloadableOperatorType.GreaterThanOrEqual; .)
-	|
-	"CType"		(. operatorType = OverloadableOperatorType.CType; .)
-	|
-	Identifier
-	(.
-		string opName = t.val; 
-		if (string.Equals(opName, "istrue", StringComparison.InvariantCultureIgnoreCase)) {
-			operatorType = OverloadableOperatorType.IsTrue;
-		} else if (string.Equals(opName, "isfalse", StringComparison.InvariantCultureIgnoreCase)) {
-			operatorType = OverloadableOperatorType.IsFalse;
-		} else {
-			Error("Invalid operator. Possible operators are '+', '-', 'Not', 'IsTrue', 'IsFalse'.");
-		}
-	.)
-	.
-
-EventAccessorDeclaration<out EventAddRemoveRegion eventAccessorDeclaration>
-	(.
-		Statement stmt = null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		AttributeSection section;
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		eventAccessorDeclaration = null;
-	.) =
-	{ AttributeSection<out section> (. attributes.Add(section); .) }
-	(
-			"AddHandler" [ "(" [ FormalParameterList<p> ] ")" ] EOL
-			Block<out stmt> "End" "AddHandler" EndOfStmt
-			(.
-				eventAccessorDeclaration = new EventAddRegion(attributes);
-				eventAccessorDeclaration.Block = (BlockStatement)stmt;
-				eventAccessorDeclaration.Parameters = p;
-			.)
-		|
-			"RemoveHandler" [ "(" [ FormalParameterList<p> ] ")" ] EOL
-			Block<out stmt> "End" "RemoveHandler" EndOfStmt
-			(.
-				eventAccessorDeclaration = new EventRemoveRegion(attributes);
-				eventAccessorDeclaration.Block = (BlockStatement)stmt;
-				eventAccessorDeclaration.Parameters = p;
-			.)
-		|
-			"RaiseEvent" [ "(" [ FormalParameterList<p> ] ")" ] EOL
-			Block<out stmt> "End" "RaiseEvent" EndOfStmt
-			(.
-				eventAccessorDeclaration = new EventRaiseRegion(attributes);
-				eventAccessorDeclaration.Block = (BlockStatement)stmt;
-				eventAccessorDeclaration.Parameters = p;
-			.)
-	)
-	.
-
-/* 9.7 */
-AccessorDecls<out PropertyGetRegion getBlock, out PropertySetRegion setBlock>
-	(.
-		List<AttributeSection> attributes = new List<AttributeSection>();
-		AttributeSection section;
-		getBlock = null;
-		setBlock = null; 
-	.) =
-	{ AttributeSection<out section> (. attributes.Add(section); .) }
-	(
-		GetAccessorDecl<out getBlock, attributes>
-		[
-			(. attributes = new List<AttributeSection>(); .)
-			{ AttributeSection<out section> (. attributes.Add(section); .) }
-			SetAccessorDecl<out setBlock, attributes>
-		]
-		|
-		SetAccessorDecl<out setBlock, attributes>
-		[
-			(. attributes = new List<AttributeSection>(); .)
-			{ AttributeSection<out section> (. attributes.Add(section); .) }
-			GetAccessorDecl<out getBlock, attributes>
-		]
-	)
-	.
-
-/* 9.7.1 */
-GetAccessorDecl<.out PropertyGetRegion getBlock, List<AttributeSection> attributes.>
-	(. Statement stmt = null; Modifiers m; .)
-=
-	PropertyAccessorAccessModifier<out m>
-	"Get"
-	(. Location startLocation = t.Location; .)
-	EOL
-	Block<out stmt>
-	(. getBlock = new PropertyGetRegion((BlockStatement)stmt, attributes); .)
-	"End" "Get"
-	(. getBlock.Modifier = m; .)
-	(. getBlock.StartLocation = startLocation; getBlock.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	.
-
-/* 9.7.2 */
-SetAccessorDecl<.out PropertySetRegion setBlock, List<AttributeSection> attributes.>
-	(.
-		Statement stmt = null;
-		List<ParameterDeclarationExpression> p = new List<ParameterDeclarationExpression>();
-		Modifiers m;
-	.)
-=
-	PropertyAccessorAccessModifier<out m>
-	"Set"
-	(. Location startLocation = t.Location; .)
-	[ "("	[ FormalParameterList<p> ] ")" ]
-	EOL
-	Block<out stmt>
-	(.
-		setBlock = new PropertySetRegion((BlockStatement)stmt, attributes);
-		setBlock.Modifier = m;
-		setBlock.Parameters = p;
-	.)
-	"End" "Set"
-	(. setBlock.StartLocation = startLocation; setBlock.EndLocation = t.EndLocation; .)
-	EndOfStmt
-	.
-
-/* 9.5 */
-ConstantDeclarator<.List<VariableDeclaration> constantDeclaration.>
-	(.
-		Expression expr = null;
-		TypeReference type = null;
-		string name = String.Empty;
-		Location location;
-	.) =
-	Identifier				(. name = t.val; location = t.Location; .)
-	["As" TypeName<out type> ]
-	"=" Expr<out expr>
-	(.
-		VariableDeclaration f = new VariableDeclaration(name, expr);
-		f.TypeReference = type;
-		f.StartLocation = location;
-		constantDeclaration.Add(f);
-	.)
-.
-
-/* 9.6 */
-VariableDeclarator<.List<VariableDeclaration> fieldDeclaration.>
-=
-	Identifier (. string name = t.val; .)
-	VariableDeclaratorPartAfterIdentifier<fieldDeclaration, name>
-.
-
-VariableDeclaratorPartAfterIdentifier<.List<VariableDeclaration> fieldDeclaration, string name.>
-	(.
-		Expression expr = null;
-		TypeReference type = null;
-		ArrayList rank = null;
-		List<Expression> dimension = null;
-		Location startLocation = t.Location;
-	.) =
-	[ IF(IsSize() && !IsDims()) ArrayInitializationModifier<out dimension> ]
-	[ IF(IsDims())              ArrayNameModifier<out rank> ]
-	(
-		IF (IsObjectCreation()) "As" ObjectCreateExpression<out expr>
-		(.
-			if (expr is ObjectCreateExpression) {
-				type = ((ObjectCreateExpression)expr).CreateType.Clone();
-			} else {
-				type = ((ArrayCreateExpression)expr).CreateType.Clone();
-			}
-		.)
-	|
-		[ "As" TypeName<out type>
-		  (.
-			if (type != null) {
-				for (int i = fieldDeclaration.Count - 1; i >= 0; i--) {
-					VariableDeclaration vd = fieldDeclaration[i];
-					if (vd.TypeReference.Type.Length > 0) break;
-					TypeReference newType = type.Clone();
-					newType.RankSpecifier = vd.TypeReference.RankSpecifier;
-					vd.TypeReference = newType;
-				}
-			}
-		  .)
-		]
-		(.
-			if (type == null && (dimension != null || rank != null)) {
-				type = new TypeReference("");
-			}
-			if (dimension != null) {
-				if(type.RankSpecifier != null) {
-					Error("array rank only allowed one time");
-				} else {
-					if (rank == null) {
-						type.RankSpecifier = new int[] { dimension.Count - 1 };
-					} else {
-						rank.Insert(0, dimension.Count - 1);
-						type.RankSpecifier = (int[])rank.ToArray(typeof(int));
-					}
-					expr = new ArrayCreateExpression(type.Clone(), dimension);
-				}
-			} else if (rank != null) {
-				if(type.RankSpecifier != null) {
-					Error("array rank only allowed one time");
-				} else {
-					type.RankSpecifier = (int[])rank.ToArray(typeof(int));
-				}
-			}
-		.)
-		[ "=" Expr<out expr> ]
-	)
-	(.
-		VariableDeclaration varDecl = new VariableDeclaration(name, expr, type);
-		varDecl.StartLocation = startLocation;
-		varDecl.EndLocation = t.Location;
-		fieldDeclaration.Add(varDecl);
-	.)
-.
-
-/* 6.8 */
-ArrayInitializationModifier<.out List<Expression> arrayModifiers.>
-(.
-	arrayModifiers = null;
-.) =
-	"(" InitializationRankList<out arrayModifiers> ")"
-.
-
-/* 7.5.4.3 */
-InitializationRankList<.out List<Expression> rank.>
-(.
-	rank = new List<Expression>();
-	Expression expr = null;
-.) =
-	Expr<out expr>
-	[	"To" (. EnsureIsZero(expr); .)
-		Expr<out expr>
-	]
-	(. if (expr != null) { rank.Add(expr); } .)
-	{	","
-		Expr<out expr>
-		[	"To" (. EnsureIsZero(expr); .)
-			Expr<out expr>
-		]
-		(. if (expr != null) { rank.Add(expr); } .)
-	}
-.
-
-/* 9.6.3.4 */
-CollectionInitializer<out CollectionInitializerExpression outExpr>
-	(.
-		Expression expr = null;
-		CollectionInitializerExpression initializer = new CollectionInitializerExpression();
-		Location startLocation = la.Location;
-	.) =
-	"{"
-	[
-		Expr<out expr>
-		(.
-			if (expr != null) { initializer.CreateExpressions.Add(expr); }
-		.)
-		{
-			IF (NotFinalComma()) "," Expr<out expr>
-			(. if (expr != null) { initializer.CreateExpressions.Add(expr); } .)
-		}
-	]
-	"}"
-	(.
-		outExpr = initializer;
-		outExpr.StartLocation = startLocation;
-		outExpr.EndLocation = t.EndLocation;
-	.)
-.
-
-Charset<out CharsetModifier charsetModifier>
-	(. charsetModifier = CharsetModifier.None; .) =
-	| "Ansi"		(. charsetModifier = CharsetModifier.Ansi; .)
-	| "Auto"		(. charsetModifier = CharsetModifier.Auto; .)
-	| "Unicode"		(. charsetModifier = CharsetModifier.Unicode; .)
-	.
-
-/* 9.2.6 */
-HandlesClause<.out List<string> handlesClause.>
-	(.
-		handlesClause = new List<string>();
-		string name;
-	.) =
-	"Handles" EventMemberSpecifier<out name>	(. if (name != null) handlesClause.Add(name); .)
-	{ "," EventMemberSpecifier<out name>		(. if (name != null) handlesClause.Add(name); .) }
-	.
-
-/* 7.8. */
-InterfaceBase<.out List<TypeReference> bases.>
-	(.
-		TypeReference type;
-		bases = new List<TypeReference>();
-	.) =
-	"Inherits"
-	TypeName<out type> (. if (type != null) bases.Add(type); .)
-	{
-		","
-		TypeName<out type> (. if (type != null) bases.Add(type); .)
-	}
-	EndOfStmt
-	.
-
-/* 7.2 */
-TypeImplementsClause<.out List<TypeReference> baseInterfaces.>
-	(.
-		baseInterfaces = new List<TypeReference>();
-		TypeReference type = null;
-	.) =
-	"Implements" TypeName<out type>
-	(.
-		if (type != null) baseInterfaces.Add(type);
-	.)
-	{
-		"," TypeName<out type>
-		(. if (type != null) baseInterfaces.Add(type); .)
-	}
-	EndOfStmt
-	.
-
-/* 9.1 */
-ImplementsClause<.out List<InterfaceImplementation> baseInterfaces.>
-	(.
-		baseInterfaces = new List<InterfaceImplementation>();
-		TypeReference type = null;
-		string memberName = null;
-	.) =
-	"Implements"
-	NonArrayTypeName<out type, false>
-	(. if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); .)
-	(. baseInterfaces.Add(new InterfaceImplementation(type, memberName)); .)
-	{ ","
-		NonArrayTypeName<out type, false>
-		(. if (type != null) memberName = TypeReference.StripLastIdentifierFromType(ref type); .)
-		(. baseInterfaces.Add(new InterfaceImplementation(type, memberName)); .)
-	}
-.
-
-EventMemberSpecifier<out string name>
-(. string eventName; .)
-=
-	( Identifier | "MyBase" | "Me" )
-	(. name = t.val; .)
-	"."
-	IdentifierOrKeyword<out eventName>
-	(. name = name + "." + eventName; .)
-.
-
-Expr<out Expression expr>
-	(. expr = null; Location startLocation = la.Location; .)
-	=
-	(
-		  IF ( IsQueryExpression() )
-		  GREEDY QueryExpr<out expr>
-		| LambdaExpr<out expr>
-		| DisjunctionExpr<out expr>
-	)
-	(.
-		if (expr != null) {
-			expr.StartLocation = startLocation;
-			expr.EndLocation = t.EndLocation;
-		}
-	.)
-.
-
-AssignmentOperator<out AssignmentOperatorType op>
-	(. op = AssignmentOperatorType.None; .) =
-	"="		(. op = AssignmentOperatorType.Assign; .)
-	| "&="	(. op = AssignmentOperatorType.ConcatString; .)
-	| "+="	(. op = AssignmentOperatorType.Add; .)
-	| "-="	(. op = AssignmentOperatorType.Subtract; .)
-	| "*="	(. op = AssignmentOperatorType.Multiply; .)
-	| "/="	(. op = AssignmentOperatorType.Divide; .)
-	| "\\="	(. op = AssignmentOperatorType.DivideInteger; .)
-	| "^="	(. op = AssignmentOperatorType.Power; .)
-	| "<<="	(. op = AssignmentOperatorType.ShiftLeft; .)
-	| ">>="	(. op = AssignmentOperatorType.ShiftRight; .)
-	.
-
-/* 11.4 */
-SimpleExpr<out Expression pexpr>
-(. string name; Location startLocation = la.Location; .)
-=
-(
-	SimpleNonInvocationExpression<out pexpr>
-	{
-			"." (
-				XmlOpenTag IdentifierOrKeyword<out name> XmlCloseTag
-				(. pexpr = new XmlMemberAccessExpression(pexpr, XmlAxisType.Element, name, true); .)
-				| IdentifierOrKeyword<out name>
-				(. pexpr = new MemberReferenceExpression(pexpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
-			)
-			[ IF (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)
-					"(" "Of" TypeArgumentList<((MemberReferenceExpression)pexpr).TypeArguments> ")"
-			]
-		|	"!" IdentifierOrKeyword<out name> (. pexpr = new BinaryOperatorExpression(pexpr, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); .)
-		|	(. XmlAxisType type = XmlAxisType.Attribute; bool isXmlName = false; .)
-			( ".@" | "..." (. type = XmlAxisType.Descendents; .) ) [ XmlOpenTag (. isXmlName = true; .) ] IdentifierOrKeyword<out name> [ XmlCloseTag ]
-			(. pexpr = new XmlMemberAccessExpression(pexpr, type, name, isXmlName); .)
-		|	InvocationExpression<ref pexpr>
-	}
-)
-(.
-	if (pexpr != null) {
-		pexpr.StartLocation = startLocation;
-		pexpr.EndLocation = t.EndLocation;
-	}
-.)
-.
-
-SimpleNonInvocationExpression<out Expression pexpr>
-(.
-	Expression expr;
-	CollectionInitializerExpression cie;
-	TypeReference type = null;
-	string name = String.Empty;
-	Location startLocation = la.Location;
-	pexpr = null;
-.) =
-	(
-		(
-			/* 11.4.1 */ 
-			LiteralString							(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-		|	LiteralCharacter						(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-		|	LiteralSingle							(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-		|	LiteralDouble							(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-		|	LiteralInteger						(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-		|	LiteralDate							(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-		|	LiteralDecimal						(.pexpr = new PrimitiveExpression(t.literalValue, t.val) { LiteralFormat = t.literalFormat };  .)
-			/* True, False and Nothing are handled as literals in the spec */
-		|	"True"											(.pexpr = new PrimitiveExpression(true, "true");  .)
-		|	"False"											(.pexpr = new PrimitiveExpression(false, "false"); .)
-		|	"Nothing"											(.pexpr = new PrimitiveExpression(null, "null");  .)
-		|	/* 11.4.2 */ "(" Expr<out expr> ")" 				(. pexpr = new ParenthesizedExpression(expr); .)
-		|	/* 11.4.4 */ Identifier
-				(. 	pexpr = new IdentifierExpression(t.val);
-					pexpr.StartLocation = t.Location; pexpr.EndLocation = t.EndLocation;
-				.)
-				[ IF (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)
-					"(" "Of" TypeArgumentList<((IdentifierExpression)pexpr).TypeArguments> ")"
-				]
-		|	(. string val = String.Empty; .)
-			( PrimitiveTypeName<out val> | "Object" (. val = "System.Object"; .) )
-			(. pexpr = new TypeReferenceExpression(new TypeReference(val, true)); .)
-		|	"Me"							(. pexpr = new ThisReferenceExpression(); .)
-		|	(. Expression retExpr = null; .)
-			( "MyBase"										(. retExpr = new BaseReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation }; .)
-			| "MyClass"										(. retExpr = new ClassReferenceExpression() { StartLocation = t.Location, EndLocation = t.EndLocation }; .)
-			)
-			"." IdentifierOrKeyword<out name>				(. pexpr = new MemberReferenceExpression(retExpr, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
-		|	"Global" "."
-			Identifier (. type = new TypeReference(t.val ?? ""); .)
-			/* fallback to "" is required if the token wasn't an identifier (->parser error but no exception) */
-			(. type.IsGlobal = true; .)
-			(. pexpr = new TypeReferenceExpression(type); .)
-		|	ObjectCreateExpression<out expr>					(. pexpr = expr; .)
-		|	CollectionInitializer<out cie>					(. pexpr = cie; .)
-		|	/* 11.11 : Casts */
-			(. CastType castType = CastType.Cast; .)
-			( "DirectCast"
-			| "CType"   (. castType = CastType.Conversion; .)
-			| "TryCast" (. castType = CastType.TryCast; .)
-			)
-			"(" Expr<out expr> "," TypeName<out type> ")"
-			(. pexpr = new CastExpression(type, expr, castType); .)
-		|	/* 11.11 */ CastTarget<out type> "(" Expr<out expr> ")"	(. pexpr = new CastExpression(type, expr, CastType.PrimitiveConversion); .)
-		|	/* 11.4.5 */ "AddressOf" SimpleExpr<out expr>			(. pexpr = new AddressOfExpression(expr); .)
-		|	/* 11.5.1 */ "GetType" "(" GetTypeTypeName<out type> ")"	(. pexpr = new TypeOfExpression(type); .)
-		|	/* 11.5.2 */ "TypeOf" SimpleExpr<out expr> "Is" TypeName<out type> (. pexpr = new TypeOfIsExpression(expr, type); .)
-		|   /* 11.22 */ ConditionalExpression<out pexpr>
-		| XmlLiteralExpression<out pexpr>
-		)
-	|
-		(
-			/* this form only occurs in WithStatements */
-			"." (
-				XmlOpenTag IdentifierOrKeyword<out name> XmlCloseTag
-				(. pexpr = new XmlMemberAccessExpression(null, XmlAxisType.Element, name, true) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
-				| IdentifierOrKeyword<out name>
-				(. pexpr = new MemberReferenceExpression(null, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
-			) |
-			"!" IdentifierOrKeyword<out name> (. pexpr = new BinaryOperatorExpression(null, BinaryOperatorType.DictionaryAccess, new PrimitiveExpression(name, name) { StartLocation = t.Location, EndLocation = t.EndLocation }); .)
-			| (. XmlAxisType axisType = XmlAxisType.Element; bool isXmlIdentifier = false; .)
-			( "..." (. axisType = XmlAxisType.Descendents; .) | ".@" (. axisType = XmlAxisType.Attribute; .) ) (
-				[ XmlOpenTag (. isXmlIdentifier = true; .) ] IdentifierOrKeyword<out name> [ XmlCloseTag ]
-				(. pexpr = new XmlMemberAccessExpression(null, axisType, name, isXmlIdentifier); .)
-			)
-		)
-	)
-(.
-	if (pexpr != null) {
-		pexpr.StartLocation = startLocation;
-		pexpr.EndLocation = t.EndLocation;
-	}
-.)
-.
-
-XmlLiteralExpression<out Expression pexpr>
-(.
-	List<XmlExpression> exprs = new List<XmlExpression>();
-	XmlExpression currentExpression = null;
-.)
-	=
-	(
-		XmlContentExpression<exprs> { XmlContentExpression<exprs> } [ XmlElement<out currentExpression> (. exprs.Add(currentExpression); .) { XmlContentExpression<exprs> } ]
-	|
-		XmlElement<out currentExpression> (. exprs.Add(currentExpression); .) { XmlContentExpression<exprs> }
-	)
-	(.
-		if (exprs.Count > 1) {
-			pexpr = new XmlDocumentExpression() { Expressions = exprs };
-		} else {
-			pexpr = exprs[0];
-		}
-	.)
-.
-
-XmlContentExpression<.List<XmlExpression> exprs.> =
-(. XmlContentExpression expr = null; .)
-	(
-		XmlContent (. expr = new XmlContentExpression(t.val, XmlContentType.Text); .)
-		| XmlCData (. expr = new XmlContentExpression(t.val, XmlContentType.CData); .)
-		| XmlComment (. expr = new XmlContentExpression(t.val, XmlContentType.Comment); .)
-		| XmlProcessingInstruction (. expr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction); .)
-	)
-	(.
-		expr.StartLocation = t.Location;
-		expr.EndLocation = t.EndLocation;
-		exprs.Add(expr);
-	.)
-.
-
-XmlNestedContent<out XmlExpression expr>
-	(. XmlExpression tmpExpr = null; Location start = la.Location; .)
-=
-	(
-		XmlContent (. tmpExpr = new XmlContentExpression(t.val, XmlContentType.Text); .)
-		| XmlCData (. tmpExpr = new XmlContentExpression(t.val, XmlContentType.CData); .)
-		| XmlComment (. tmpExpr = new XmlContentExpression(t.val, XmlContentType.Comment); .)
-		| XmlProcessingInstruction (. tmpExpr = new XmlContentExpression(t.val, XmlContentType.ProcessingInstruction); .)
-		| XmlStartInlineVB (. Expression innerExpression; .) Expr<out innerExpression> XmlEndInlineVB (. tmpExpr = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression }; .)
-		| XmlElement<out tmpExpr>
-	)
-	(.
-		if (tmpExpr.StartLocation.IsEmpty)
-			tmpExpr.StartLocation = start;
-		if (tmpExpr.EndLocation.IsEmpty)
-			tmpExpr.EndLocation = t.EndLocation;
-		expr = tmpExpr;
-	.)
-.
-
-XmlElement<out XmlExpression expr>
-	(. XmlElementExpression el = new XmlElementExpression(); .)
-=
-	(
-		XmlOpenTag (. el.StartLocation = t.Location; .)
-		( XmlStartInlineVB (. Expression innerExpression; .) Expr<out innerExpression> XmlEndInlineVB
-		(. el.NameExpression = new XmlEmbeddedExpression() { InlineVBExpression = innerExpression }; .)
-		| Identifier (. el.XmlName = t.val; .) ) { XmlAttribute<el.Attributes> }
-		( XmlCloseTagEmptyElement (. el.EndLocation = t.EndLocation; .) | XmlCloseTag { (. XmlExpression child; .) XmlNestedContent<out child> (. el.Children.Add(child); .) } XmlOpenEndTag { ANY } XmlCloseTag (. el.EndLocation = t.EndLocation; .) )
-	)
-	(. expr = el; .)
-.
-
-XmlAttribute<.List<XmlExpression> attrs.>
-	(. Location start = la.Location; .)
-=
-		Identifier (. string name = t.val; .) "="
-		(. string literalValue = null; Expression expressionValue = null; bool useDoubleQuotes = false; .)
-		( LiteralString (. literalValue = t.literalValue.ToString(); useDoubleQuotes = t.val[0] == '"'; .) | XmlStartInlineVB Expr<out expressionValue> XmlEndInlineVB )
-		(. attrs.Add(new XmlAttributeExpression() { Name = name, ExpressionValue = expressionValue, LiteralValue = literalValue, UseDoubleQuotes = useDoubleQuotes, StartLocation = start, EndLocation = t.EndLocation }); .)
-	|
-		XmlStartInlineVB (. Expression innerExpression; .) Expr<out innerExpression> XmlEndInlineVB
-		(. attrs.Add(new XmlEmbeddedExpression() { InlineVBExpression = innerExpression, StartLocation = start, EndLocation = t.EndLocation }); .)
-.
-
-ConditionalExpression<out Expression expr>
-	(.
-		ConditionalExpression conditionalExpression = new ConditionalExpression();
-		BinaryOperatorExpression binaryOperatorExpression = new BinaryOperatorExpression();
-		conditionalExpression.StartLocation = binaryOperatorExpression.StartLocation = la.Location;
-		
-		Expression condition = null;
-		Expression trueExpr = null;
-		Expression falseExpr = null;
-	.)
-=
-	"If" "(" Expr<out condition> "," Expr<out trueExpr> [ "," Expr<out falseExpr> ] ")"
-	(.
-		if(falseExpr != null)
-		{
-			conditionalExpression.Condition = condition;
-			conditionalExpression.TrueExpression = trueExpr;
-			conditionalExpression.FalseExpression = falseExpr;
-			conditionalExpression.EndLocation = t.EndLocation;
-			
-			expr = conditionalExpression;
-		}
-		else
-		{
-			binaryOperatorExpression.Left = condition;
-			binaryOperatorExpression.Right = trueExpr;
-			binaryOperatorExpression.Op = BinaryOperatorType.NullCoalescing;
-			binaryOperatorExpression.EndLocation = t.EndLocation;
-			
-			expr = binaryOperatorExpression;
-		}
-	.)
-.	
-
-InvocationExpression<ref Expression pexpr>
-(. List<Expression> parameters = null; .)
-=
-	"(" (. Location start = t.Location; .)
-	ArgumentList<out parameters>
-	")"
-	(.
-		pexpr = new InvocationExpression(pexpr, parameters);
-	.)
-	(. pexpr.StartLocation = start; pexpr.EndLocation = t.Location; .)
-.
-
-/* 11.11 */
-CastTarget<out TypeReference type>
-	(.
-		type = null;
-	.) =
-	"CBool"		(. type = new TypeReference("System.Boolean", true); .)
-	| "CByte"	(. type = new TypeReference("System.Byte", true); .)
-	| "CSByte"	(. type = new TypeReference("System.SByte", true); .)
-	| "CChar"	(. type = new TypeReference("System.Char", true); .)
-	| "CDate"	(. type = new TypeReference("System.DateTime", true); .)
-	| "CDec"	(. type = new TypeReference("System.Decimal", true); .)
-	| "CDbl"	(. type = new TypeReference("System.Double", true); .)
-	| "CShort"	(. type = new TypeReference("System.Int16", true); .)
-	| "CInt"	(. type = new TypeReference("System.Int32", true); .)
-	| "CLng"	(. type = new TypeReference("System.Int64", true); .)
-	| "CUShort"	(. type = new TypeReference("System.UInt16", true); .)
-	| "CUInt"	(. type = new TypeReference("System.UInt32", true); .)
-	| "CULng"	(. type = new TypeReference("System.UInt64", true); .)
-	| "CObj"	(. type = new TypeReference("System.Object", true); .)
-	| "CSng"	(. type = new TypeReference("System.Single", true); .)
-	| "CStr"	(. type = new TypeReference("System.String", true); .)
-	.
-
-DisjunctionExpr<out Expression outExpr>
-(.
-	Expression expr;
-	BinaryOperatorType op = BinaryOperatorType.None;
-	Location startLocation = la.Location;
-.) =
-	ConjunctionExpr<out outExpr>
-	{
-		(
-			  "Or"     (. op = BinaryOperatorType.BitwiseOr; .)
-			| "OrElse" (. op = BinaryOperatorType.LogicalOr; .)
-			| "Xor"    (. op = BinaryOperatorType.ExclusiveOr; .)
-		)
-		ConjunctionExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
-	}
-.
-
-ConjunctionExpr<out Expression outExpr>
-(.
-	Expression expr;
-	BinaryOperatorType op = BinaryOperatorType.None;
-	Location startLocation = la.Location;
-.) =
-	NotExpr<out outExpr>
-	{
-		(
-			  "And"     (. op = BinaryOperatorType.BitwiseAnd; .)
-			| "AndAlso" (. op = BinaryOperatorType.LogicalAnd; .)
-		)
-		NotExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
-	}
-.
-
-NotExpr<out Expression outExpr> 
-	(. UnaryOperatorType uop = UnaryOperatorType.None; .) =
-	{	"Not" (. uop = UnaryOperatorType.Not; .) }
-	ComparisonExpr<out outExpr>
-                (. if (uop != UnaryOperatorType.None)
-	                   outExpr = new UnaryOperatorExpression(outExpr, uop);
-                .)
-	.
-
-ComparisonExpr<out Expression outExpr>
-(.
-	Expression expr;
-	BinaryOperatorType op = BinaryOperatorType.None;
-	Location startLocation = la.Location;
-.) =
-	ShiftExpr<out outExpr>
-	{
-		(
-			"<"    (. op = BinaryOperatorType.LessThan; .)
-			| ">"  (. op = BinaryOperatorType.GreaterThan; .)
-			| "<=" (. op = BinaryOperatorType.LessThanOrEqual; .)
-			| ">=" (. op = BinaryOperatorType.GreaterThanOrEqual; .)
-			| "<>"		(. op = BinaryOperatorType.InEquality; .)
-			| "=" 		(. op = BinaryOperatorType.Equality; .)
-			| "Like"	(. op = BinaryOperatorType.Like; .)
-			| "Is"	(. op = BinaryOperatorType.ReferenceEquality; .)
-			| "IsNot" (. op = BinaryOperatorType.ReferenceInequality; .)
-		)
-		(
-			ShiftExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
-		| (. Location startLocation2 = la.Location; .)
-			"Not"
-			ShiftExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, new UnaryOperatorExpression(expr, UnaryOperatorType.Not) { StartLocation = startLocation2, EndLocation = t.EndLocation }) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
-		)
-	}
-.
-
-ShiftExpr<out Expression outExpr>
-	(.
-		Expression expr;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		Location startLocation = la.Location;
-	.) =
-	ConcatenationExpr<out outExpr> 
-	{
-		(
-			"<<"   (. op = BinaryOperatorType.ShiftLeft; .)
-			| ">>" (. op = BinaryOperatorType.ShiftRight; .)
-		)
-		ConcatenationExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) 
-	}
-	.
-
-ConcatenationExpr<out Expression outExpr>
-(. Expression expr; Location startLocation = la.Location; .)
-=
-	AdditiveExpr<out outExpr> { "&" AdditiveExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Concat, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
-.
-
-AdditiveExpr<out Expression outExpr>
-(.
-	Expression expr;
-	BinaryOperatorType op = BinaryOperatorType.None;
-	Location startLocation = la.Location;
-.) =
-	ModuloExpr<out outExpr>
-	{
-		(
-			  "+"   (. op = BinaryOperatorType.Add; .)
-			| "-" (. op = BinaryOperatorType.Subtract; .)
-		)
-		ModuloExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .)
-	}
-.
-
-ModuloExpr<out Expression outExpr>
-(. Expression expr; Location startLocation = la.Location; .)
-= 
-	IntegerDivisionExpr<out outExpr> { "Mod" IntegerDivisionExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Modulus, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
-.
-
-IntegerDivisionExpr<out Expression outExpr>
-(. Expression expr; Location startLocation = la.Location; .)
-=
-	MultiplicativeExpr<out outExpr> { "\\" MultiplicativeExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.DivideInteger, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
-.
-
-MultiplicativeExpr<out Expression outExpr>
-(.
-	Expression expr;
-	BinaryOperatorType op = BinaryOperatorType.None;
-	Location startLocation = la.Location;
-.) =
-	UnaryExpr<out outExpr>
-	{
-		(
-			"*"   (. op = BinaryOperatorType.Multiply; .)
-			| "/" (. op = BinaryOperatorType.Divide; .)
-		) 
-		UnaryExpr<out expr> (. outExpr = new BinaryOperatorExpression(outExpr, op, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }; .) 
-	}
-.
-
-UnaryExpr<out Expression uExpr> 
-(.
-	Expression expr;
-	UnaryOperatorType uop = UnaryOperatorType.None;
-	Location startLocation = la.Location;
-	bool isUOp = false;
-.) =
-	{ 	"+" 		(. uop = UnaryOperatorType.Plus; isUOp = true; .)
-		| "-" 		(. uop = UnaryOperatorType.Minus; isUOp = true; .)
-		| "*" 		(. uop = UnaryOperatorType.Dereference;  isUOp = true;.)
-	}
-	ExponentiationExpr<out expr>
-	(.
-		if (isUOp) {
-			uExpr = new UnaryOperatorExpression(expr, uop) { StartLocation = startLocation, EndLocation = t.EndLocation };
-		} else {
-			uExpr = expr;
-		}
-	.)
-.
-
-ExponentiationExpr<out Expression outExpr>
-(. Expression expr; Location startLocation = la.Location; .)
-=
-	SimpleExpr<out outExpr> { "^" SimpleExpr<out expr> (.  outExpr = new BinaryOperatorExpression(outExpr, BinaryOperatorType.Power, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };  .) }
-.
-	
-ObjectCreateExpression<out Expression oce>
-(.
-	TypeReference type = null;
-	CollectionInitializerExpression initializer = null;
-	List<Expression> arguments = null;
-	ArrayList dimensions = null;
-	oce = null;
-	Location startLocation = la.Location;
-	bool canBeNormal; bool canBeReDim;
-.) =
-	"New" 
-	[ NonArrayTypeName<out type, false>
-		["(" NormalOrReDimArgumentList<out arguments, out canBeNormal, out canBeReDim> ")"
-			[ IF (la.kind == Tokens.OpenParenthesis)
-				ArrayTypeModifiers<out dimensions>
-				CollectionInitializer<out initializer>
-			|	CollectionInitializer<out initializer>
-			]
-			(. if (canBeReDim && !canBeNormal && initializer == null) initializer = new CollectionInitializerExpression(); .)
-		]
-	]
-	(.
-		if (initializer == null) {
-			oce = new ObjectCreateExpression(type, arguments);
-		} else {
-			if (dimensions == null) dimensions = new ArrayList();
-			dimensions.Insert(0, (arguments == null) ? 0 : Math.Max(arguments.Count - 1, 0));
-			type.RankSpecifier = (int[])dimensions.ToArray(typeof(int));
-			ArrayCreateExpression ace = new ArrayCreateExpression(type, initializer);
-			ace.Arguments = arguments;
-			oce = ace;
-		}
-	.)
-	
-	[
-		(
-			(.
-				MemberInitializerExpression memberInitializer = null;
-				Expression anonymousMember = null;
-			.)
-			"With"
-			(.
-				CollectionInitializerExpression memberInitializers = new CollectionInitializerExpression();
-				memberInitializers.StartLocation = la.Location;
-			.)
-			"{"
-				(
-					MemberInitializer<out memberInitializer>
-						(. memberInitializers.CreateExpressions.Add(memberInitializer); .)
-					| Expr<out anonymousMember>
-						(. memberInitializers.CreateExpressions.Add(anonymousMember); .)
-				)
-				{ ","
-					(
-						MemberInitializer<out memberInitializer>
-							(. memberInitializers.CreateExpressions.Add(memberInitializer); .)
-						| Expr<out anonymousMember>
-							(. memberInitializers.CreateExpressions.Add(anonymousMember); .)
-					)
-				}
-			"}"
-			(.
-				memberInitializers.EndLocation = t.Location;
-				if(oce is ObjectCreateExpression)
-				{
-					((ObjectCreateExpression)oce).ObjectInitializer = memberInitializers;
-				}
-			.)
-		)
-	|
-		(
-			"From"
-			CollectionInitializer<out initializer>
-			(.
-				if(oce is ObjectCreateExpression)
-					((ObjectCreateExpression)oce).ObjectInitializer = initializer;
-			.)
-		)
-	]
-	(.
-		if (oce != null) {
-			oce.StartLocation = startLocation;
-			oce.EndLocation = t.EndLocation;
-		}
-	.)
-.
-
-LambdaExpr<out Expression expr>
-	(.
-		LambdaExpression lambda = null;
-	.) =
-	( SubLambdaExpression<out lambda> |
-	FunctionLambdaExpression<out lambda> )
-	(. expr = lambda; .)
-.
-
-SubLambdaExpression<out LambdaExpression lambda>
-	(.
-		lambda = new LambdaExpression();
-		lambda.ReturnType = new TypeReference("System.Void", true);
-		Statement statement = null;
-		lambda.StartLocation = la.Location;
-	.)
-=
-	"Sub" "(" [ FormalParameterList<lambda.Parameters> ] ")"
-	(
-		GREEDY EmbeddedStatement<out statement>
-		(.
-			lambda.StatementBody = statement;
-			lambda.EndLocation = t.EndLocation;
-			lambda.ExtendedEndLocation = la.Location;
-		.)
-	|
-		EOL
-		Block<out statement>
-		"End" "Sub"
-		(.
-			lambda.StatementBody = statement;
-			lambda.EndLocation = t.EndLocation;
-			lambda.ExtendedEndLocation = la.Location;
-		.)
-	)
-.
-
-FunctionLambdaExpression<out LambdaExpression lambda>
-	(.
-		lambda = new LambdaExpression();
-		TypeReference typeRef = null;
-		Expression inner = null;
-		Statement statement = null;
-		lambda.StartLocation = la.Location;
-	.)
-=
-	"Function" "(" [ FormalParameterList<lambda.Parameters> ] ")"
-	[ "As" TypeName<out typeRef> (. lambda.ReturnType = typeRef; .) ]
-	(
-		GREEDY Expr<out inner>
-		(.
-			lambda.ExpressionBody = inner;
-			lambda.EndLocation = t.EndLocation;
-			lambda.ExtendedEndLocation = la.Location;
-		.)
-	|
-		EOL
-		Block<out statement>
-		"End" "Function"
-		(.
-			lambda.StatementBody = statement;
-			lambda.EndLocation = t.EndLocation;
-			lambda.ExtendedEndLocation = la.Location;
-		.)
-	)
-.
-
-QueryExpr<out Expression expr>
-	(.
-		QueryExpression qexpr = new QueryExpression();
-		qexpr.StartLocation = la.Location;
-		expr = qexpr;
-	.) =
-	FromOrAggregateQueryOperator<qexpr.Clauses>
-	{ QueryOperator<qexpr.Clauses> }
-	(.
-		qexpr.EndLocation = t.EndLocation;
-	.)
-.
-
-FromOrAggregateQueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionFromClause fromClause = null;
-		QueryExpressionAggregateClause aggregateClause = null;
-	.) =
-	   FromQueryOperator<out fromClause>
-	   (. middleClauses.Add(fromClause); .)
-	|  AggregateQueryOperator<out aggregateClause>
-	   (. middleClauses.Add(aggregateClause); .)
-.
-
-QueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionJoinVBClause joinClause = null;
-		QueryExpressionGroupVBClause groupByClause = null;
-		QueryExpressionPartitionVBClause partitionClause = null;
-		QueryExpressionGroupJoinVBClause groupJoinClause = null;
-		QueryExpressionFromClause fromClause = null;
-		QueryExpressionAggregateClause aggregateClause = null;
-	.) =
-	   FromQueryOperator<out fromClause>
-	   (. middleClauses.Add(fromClause); .)
-	|  AggregateQueryOperator<out aggregateClause>
-	   (. middleClauses.Add(aggregateClause); .)
-    | SelectQueryOperator<middleClauses>
-	| DistinctQueryOperator<middleClauses>
-	| WhereQueryOperator<middleClauses>
-	| OrderByQueryOperator<middleClauses>
-	| PartitionQueryOperator<out partitionClause>
-	  (. middleClauses.Add(partitionClause); .)
-	| LetQueryOperator<middleClauses>
-	| JoinQueryOperator<out joinClause>
-	  (. middleClauses.Add(joinClause); .)
-	| IF(la.kind == Tokens.Group && Peek(1).kind == Tokens.Join) GroupJoinQueryOperator<out groupJoinClause>
-	  (. middleClauses.Add(groupJoinClause); .)
-	| GroupByQueryOperator<out groupByClause>
-	  (. middleClauses.Add(groupByClause); .)
-.	
-
-OrderByQueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionOrderClause orderClause = new QueryExpressionOrderClause();
-		orderClause.StartLocation = la.Location;
-		List<QueryExpressionOrdering> orderings = null;
-	.) =
-	"Order" "By" OrderExpressionList<out orderings>
-	(.
-		orderClause.Orderings = orderings;
-		orderClause.EndLocation = t.EndLocation;
-		middleClauses.Add(orderClause);
-	.)
-.
-
-OrderExpressionList<.out List<QueryExpressionOrdering> orderings.>
-	(.
-		orderings = new List<QueryExpressionOrdering>();
-		QueryExpressionOrdering ordering = null;
-	.) =
-	OrderExpression<out ordering>
-	(. orderings.Add(ordering); .)
-	{
-		"," OrderExpression<out ordering>
-		(. orderings.Add(ordering); .)
-	}
-.
-
-OrderExpression<out QueryExpressionOrdering ordering>
-	(.
-		ordering = new QueryExpressionOrdering();
-		ordering.StartLocation = la.Location;
-		ordering.Direction = QueryExpressionOrderingDirection.None;
-		Expression orderExpr = null;
-	.) =
-	Expr<out orderExpr>
-	(.
-		ordering.Criteria = orderExpr;
-	.)
-	[
-		  "Ascending" 	(. ordering.Direction = QueryExpressionOrderingDirection.Ascending; .)
-		| "Descending"	(. ordering.Direction = QueryExpressionOrderingDirection.Descending; .)
-	]
-	(. ordering.EndLocation = t.EndLocation; .)
-.
+#region General
 
-GroupByQueryOperator<out QueryExpressionGroupVBClause groupByClause>
-	(.
-		groupByClause = new QueryExpressionGroupVBClause();
-		groupByClause.StartLocation = la.Location;
-	.) =
-	"Group" ExpressionRangeVariableDeclarationList<groupByClause.GroupVariables>
-	"By" ExpressionRangeVariableDeclarationList<groupByClause.ByVariables>
-	"Into" ExpressionRangeVariableDeclarationList<groupByClause.IntoVariables>
-	(.
-		groupByClause.EndLocation = t.EndLocation;
-	.)
-.
-
-GroupJoinQueryOperator<out QueryExpressionGroupJoinVBClause groupJoinClause>
-	(.
-		groupJoinClause = new QueryExpressionGroupJoinVBClause();
-		groupJoinClause.StartLocation = la.Location;
-		QueryExpressionJoinVBClause joinClause = null;
-	.) =
-	"Group" JoinQueryOperator<out joinClause>
-	"Into"  ExpressionRangeVariableDeclarationList<groupJoinClause.IntoVariables>
-	(.
-		groupJoinClause.JoinClause = joinClause;
-		groupJoinClause.EndLocation = t.EndLocation;
-	.)
-.
-
-FromQueryOperator<out QueryExpressionFromClause fromClause>
-	(.
-	    fromClause = new QueryExpressionFromClause();
-	    fromClause.StartLocation = la.Location;
-	.) =
-	"From" CollectionRangeVariableDeclarationList<fromClause.Sources>
-	(.
-	   fromClause.EndLocation = t.EndLocation;
-	.)
-.
-
-SelectQueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionSelectVBClause selectClause = new QueryExpressionSelectVBClause();
-		selectClause.StartLocation = la.Location;
-	.) =
-	"Select" ExpressionRangeVariableDeclarationList<selectClause.Variables>
-	(.
-		selectClause.EndLocation = t.Location;
-		middleClauses.Add(selectClause);
-	.)
-.
-
-DistinctQueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionDistinctClause distinctClause = new QueryExpressionDistinctClause();
-		distinctClause.StartLocation = la.Location;
-	.) =
-	"Distinct"
-	(.
-		distinctClause.EndLocation = t.EndLocation;
-		middleClauses.Add(distinctClause);
-	.)
-.
-
-WhereQueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionWhereClause whereClause = new QueryExpressionWhereClause();
-		whereClause.StartLocation = la.Location;
-		Expression operand = null;
-	.) =
-	"Where" Expr<out operand>
-	(.
-		whereClause.Condition = operand;
-		whereClause.EndLocation = t.EndLocation;
-		
-		middleClauses.Add(whereClause);
-	.)
-.
-
-PartitionQueryOperator<out QueryExpressionPartitionVBClause partitionClause>
-	(.
-		partitionClause = new QueryExpressionPartitionVBClause();
-		partitionClause.StartLocation = la.Location;
-		Expression expr = null;
-	.) =
-	  (
-	   "Take" (. partitionClause.PartitionType = QueryExpressionPartitionType.Take; .)
-	  [ "While" (. partitionClause.PartitionType = QueryExpressionPartitionType.TakeWhile; .) ]
-	| "Skip" (. partitionClause.PartitionType = QueryExpressionPartitionType.Skip; .)
-      [ "While" (. partitionClause.PartitionType = QueryExpressionPartitionType.SkipWhile; .) ]
-      )
-	  Expr<out expr>
-	(.
-		partitionClause.Expression = expr;
-		partitionClause.EndLocation = t.EndLocation;
-	.)
-.
-
-AggregateQueryOperator<out QueryExpressionAggregateClause aggregateClause>
-	(.
-		aggregateClause = new QueryExpressionAggregateClause();
-		aggregateClause.IntoVariables = new List<ExpressionRangeVariable>();
-		aggregateClause.StartLocation = la.Location;
-		CollectionRangeVariable source;
-	.) =
-	"Aggregate" CollectionRangeVariableDeclaration<out source>
-	(.
-		aggregateClause.Source = source;
-	.)
-	{
-		QueryOperator<aggregateClause.MiddleClauses>
-	}
-	"Into" ExpressionRangeVariableDeclarationList<aggregateClause.IntoVariables>
-	(.
-		aggregateClause.EndLocation = t.EndLocation;
-	.)
-.
-
-LetQueryOperator<.List<QueryExpressionClause> middleClauses.>
-	(.
-		QueryExpressionLetVBClause letClause = new QueryExpressionLetVBClause();
-		letClause.StartLocation = la.Location;
-	.) =
-	"Let" ExpressionRangeVariableDeclarationList<letClause.Variables>
-	(.
-		letClause.EndLocation = t.EndLocation;
-		middleClauses.Add(letClause);
-	.)
-.	
-
-ExpressionRangeVariableDeclarationList<.List<ExpressionRangeVariable> variables.>
-	(.
-		ExpressionRangeVariable variable = null;
-	.) =
-	ExpressionRangeVariableDeclaration<out variable>
-	(. variables.Add(variable); .)
-	{ "," ExpressionRangeVariableDeclaration<out variable> (. variables.Add(variable); .) }
-.
-
-ExpressionRangeVariableDeclaration<out ExpressionRangeVariable variable>
-	(.
-		variable = new ExpressionRangeVariable();
-		variable.StartLocation = la.Location;
-		Expression rhs = null;
-		TypeReference typeName = null;
-	.) =
-	[
-		IF(IsIdentifiedExpressionRange()) Identifier
-		(. variable.Identifier = t.val; .)
-		[
-			"As" TypeName<out typeName>
-			(. variable.Type = typeName; .)
-		]
-		"="
-	]
-	Expr<out rhs>
-	(.
-		variable.Expression = rhs;
-		variable.EndLocation = t.EndLocation;
-	.)
-.
-
-JoinQueryOperator<out QueryExpressionJoinVBClause joinClause>
-	(.
-		joinClause = new QueryExpressionJoinVBClause();
-		joinClause.StartLocation = la.Location;
-		CollectionRangeVariable joinVariable = null;
-		QueryExpressionJoinVBClause subJoin = null;
-		QueryExpressionJoinConditionVB condition = null;
-		
-	.) =
-	"Join" CollectionRangeVariableDeclaration<out joinVariable> 
-	(. joinClause.JoinVariable = joinVariable; .)
-	[
-		JoinQueryOperator<out subJoin>
-		(. joinClause.SubJoin = subJoin; .)
-	]
-	"On"
-	JoinCondition<out condition>
-	(. SafeAdd(joinClause, joinClause.Conditions, condition); .)
-	{
-		"And" JoinCondition<out condition>
-		(. SafeAdd(joinClause, joinClause.Conditions, condition); .)
-	}
-	(.
-		joinClause.EndLocation = t.EndLocation;
-	.)
-.
-
-CollectionRangeVariableDeclarationList<.List<CollectionRangeVariable> rangeVariables.>
-(. CollectionRangeVariable variableDeclaration; .)
-  =
-	CollectionRangeVariableDeclaration<out variableDeclaration>
-	(. rangeVariables.Add(variableDeclaration); .)
-	{ "," CollectionRangeVariableDeclaration<out variableDeclaration> (. rangeVariables.Add(variableDeclaration); .) }
-.
-
-CollectionRangeVariableDeclaration<out CollectionRangeVariable rangeVariable>
-	(.
-		rangeVariable = new CollectionRangeVariable();
-		rangeVariable.StartLocation = la.Location;
-		TypeReference typeName = null;
-		Expression inExpr = null;
-	.) =
-	Identifier (. rangeVariable.Identifier = t.val; .)
-	[ "As" TypeName<out typeName> (. rangeVariable.Type = typeName; .) ] 
-	"In" Expr<out inExpr>
-	(.
-		rangeVariable.Expression = inExpr;
-		rangeVariable.EndLocation = t.EndLocation;
-	.)
-.
-
-JoinCondition<out QueryExpressionJoinConditionVB condition>
-	(.
-		condition = new QueryExpressionJoinConditionVB();
-		condition.StartLocation = la.Location;
-		
-		Expression lhs = null;
-		Expression rhs = null;
-	.) =
-	Expr<out lhs> "Equals" Expr<out rhs>
-	(.
-		condition.LeftSide = lhs;
-		condition.RightSide = rhs;
-		condition.EndLocation = t.EndLocation;
-	.)
-.
-
-MemberInitializer<out MemberInitializerExpression memberInitializer>
-	(.
-		memberInitializer = new MemberInitializerExpression();
-		memberInitializer.StartLocation = la.Location;
-		Expression initExpr = null;
-		bool isKey = false;
-		string name = null;
-	.) =
-	[ "Key" (. isKey = true; .) ]
-	"." IdentifierOrKeyword<out name> "=" Expr<out initExpr>
-	(.
-		memberInitializer.Name = name;
-		memberInitializer.Expression = initExpr;
-		memberInitializer.IsKey = isKey;
-		memberInitializer.EndLocation = t.EndLocation;
-	.)
-.
-
-/* 9.3.2 */
-ArgumentList<.out List<Expression> arguments.>
-	(.
-		arguments = new List<Expression>();
-		Expression expr = null;
-	.) =
-	[ Argument<out expr> ]
-	{ "," (. arguments.Add(expr ?? Expression.Null); expr = null; .)
-		[ Argument<out expr> ]
-		(. if (expr == null) expr = Expression.Null; .)
-	}
-	(. if (expr != null) arguments.Add(expr); .)
-.
-
-/* argument list that hasn't decided if it is method call or array initialisation */
-NormalOrReDimArgumentList<.out List<Expression> arguments, out bool canBeNormal, out bool canBeRedim.>
-	(.
-		arguments = new List<Expression>();
-		canBeNormal = true; canBeRedim = !IsNamedAssign();
-		Expression expr = null;
-	.)
-=
-	[ Argument<out expr>
-	  [ "To" (. EnsureIsZero(expr); canBeNormal = false; .)
-	    Expr<out expr>
-	] ]
-	{ ","
-		(. if (expr == null) canBeRedim = false; .)
-		(. arguments.Add(expr ?? Expression.Null); expr = null; .)
-		(. canBeRedim &= !IsNamedAssign(); .)
-		[ Argument<out expr>
-		  [ "To" (. EnsureIsZero(expr); canBeNormal = false; .)
-		    Expr<out expr>
-		] ]
-		(. if (expr == null) { canBeRedim = false; expr = Expression.Null; } .)
-	}
-	(. if (expr != null) arguments.Add(expr); else canBeRedim = false; .)
-.
-
-/* Spec, 11.8 */
-Argument<out Expression argumentexpr>
-	(.
-		Expression expr;
-		argumentexpr = null;
-		string name;
-		Location startLocation = la.Location;
-	.) =
-	IF(IsNamedAssign()) Identifier (. name = t.val;  .) ":=" Expr<out expr>
-	(.
-		argumentexpr = new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation };
-	.)
-	|
-	Expr<out argumentexpr>
-.
-
-/* 7.1. */
-TypeName<out TypeReference typeref>
-(. ArrayList rank = null; Location startLocation = la.Location; .)
-=
-	NonArrayTypeName<out typeref, false>
-	ArrayTypeModifiers<out rank>
-	(.
-		if (typeref != null) {
-			if (rank != null) {
-				typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
-			}
-			typeref.StartLocation = startLocation;
-			typeref.EndLocation = t.EndLocation;
-		}
-	.)
-.
-
-GetTypeTypeName<out TypeReference typeref>
-(. ArrayList rank = null; .)
-=
-	NonArrayTypeName<out typeref, true>
-	ArrayTypeModifiers<out rank>
-	(.	if (rank != null && typeref != null) {
-			typeref.RankSpecifier = (int[])rank.ToArray(typeof(int));
-		}
-	.)
-.
-
-/* 7.1 */
-NonArrayTypeName<out TypeReference typeref, bool canBeUnbound>
-(.
-	string name;
-	typeref = null;
-	bool isGlobal = false;
-.) =
-	(
-		[ "Global" "." (. isGlobal = true; .) ]
-		QualIdentAndTypeArguments<out typeref, canBeUnbound>
-		(. typeref.IsGlobal = isGlobal; .)
-		{ "." (. TypeReference nestedTypeRef; .)
-			QualIdentAndTypeArguments<out nestedTypeRef, canBeUnbound>
-			(. typeref = new InnerClassTypeReference(typeref, nestedTypeRef.Type, nestedTypeRef.GenericTypes); .)
-		}
-	)
-	| "Object" (. typeref = new TypeReference("System.Object", true); .)
-		[
-	  	"?"
-	  	(.
-		  	List<TypeReference> typeArguments = new List<TypeReference>(1);
-		  	if (typeref != null) typeArguments.Add(typeref);
-			typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
-		.)			
-	  ]
-	
-	| PrimitiveTypeName<out name> (. typeref = new TypeReference(name, true); .)
-	  [
-		"?"
-	  	(.
-		  	List<TypeReference> typeArguments = new List<TypeReference>(1);
-		  	if (typeref != null) typeArguments.Add(typeref);
-			typeref = new TypeReference("System.Nullable", typeArguments) { IsKeyword = true };
-		.)			
-	  ]
-.
-
-QualIdentAndTypeArguments<out TypeReference typeref, bool canBeUnbound>
-(. string name; typeref = null; .)
-=
-	Qualident<out name>
-	(. typeref = new TypeReference(name); .)
-	[IF (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)
-		"(" "Of"
-		( IF (canBeUnbound && (la.kind == Tokens.CloseParenthesis || la.kind == Tokens.Comma))
-			(. typeref.GenericTypes.Add(NullTypeReference.Instance); .)
-			{ "," (. typeref.GenericTypes.Add(NullTypeReference.Instance); .) }
-		  | TypeArgumentList<typeref.GenericTypes>
-		)
-		")"
-	]
-.
-
-/* 7.9 */
-ArrayNameModifier<out ArrayList arrayModifiers>
-(.
-	arrayModifiers = null;
-.) =
-	ArrayTypeModifiers<out arrayModifiers>
-.
-
-
-/* 7.9 */
-ArrayTypeModifiers<out ArrayList arrayModifiers>
-(.
-	arrayModifiers = new ArrayList();
-	int i = 0;
-.) =
-	{	IF (IsDims())
-		"("
-		[ RankList<out i>]
-		(.
-			arrayModifiers.Add(i);
-		.)
-		")"
-	}
-	(.
-		if(arrayModifiers.Count == 0) {
-			 arrayModifiers = null;
-		}
-	.)
-.
-
-/* 7.9 */
-RankList<out int i>
-(. i = 0; .) =
-	{ "," (. ++i; .) }
-.
-
-/* 7.12 */
-TypeArgumentList<.List<TypeReference> typeArguments.>
-(.
-	TypeReference typeref;
-.) =
-	TypeName<out typeref> (. if (typeref != null) typeArguments.Add(typeref); .)
-	{
-		","
-		TypeName<out typeref> (. if (typeref != null) typeArguments.Add(typeref); .)
-	}
-.
-
-GlobalAttributeSection =
-	"<" (. Location startPos = t.Location; .)
-	("Assembly" | "Module")
-		(.  string attributeTarget = t.val != null ? t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture) : null;
-			List<ASTAttribute> attributes = new List<ASTAttribute>();
-			ASTAttribute attribute;
-		.)
-	":" Attribute<out attribute> (. attributes.Add(attribute); .)
-	{ IF (NotFinalComma()) ["," ("Assembly" | "Module") ":"] Attribute<out attribute> (. attributes.Add(attribute); .)}
-	[ "," ]
-	">"
-	EndOfStmt
-		(.
-			AttributeSection section = new AttributeSection {
-				AttributeTarget = attributeTarget,
-				Attributes = attributes,
-				StartLocation = startPos,
-				EndLocation = t.EndLocation
-			};
-			AddChild(section);
-		.)
-	.
-
-/* Spec, 5. */
-Attribute<out ASTAttribute attribute>
-(.
-	string name;
-	List<Expression> positional = new List<Expression>();
-	List<NamedArgumentExpression> named = new List<NamedArgumentExpression>();
-	Location startLocation = la.Location;
-.) =
-	[ "Global" "." ]
-	Qualident<out name>
-	[ AttributeArguments<positional, named> ]
-	(.
-		attribute  = new ASTAttribute(name, positional, named) { StartLocation = startLocation, EndLocation = t.EndLocation };
-	.)
-.
-
-/* Spec, 5.2.2 */
-AttributeArguments<.List<Expression> positional, List<NamedArgumentExpression> named.>
-	(.
-		bool nameFound = false;
-		string name = "";
-		Expression expr;
-	.) =
-	"("
-	[
-		IF (IsNotClosingParenthesis()) (
-			(. Location startLocation = la.Location; .)
-			[
-				IF (IsNamedAssign()) (. nameFound = true; .)
-				IdentifierOrKeyword<out name>
-				( ":=" | "=" )
-			] Expr<out expr>
-				(.
-					if (expr != null) {
-						if (string.IsNullOrEmpty(name)) { positional.Add(expr); }
-						else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
-					}
-				.)
-			{
-				","
-					(
-						IF (IsNamedAssign())	(. nameFound = true; .)
-						IdentifierOrKeyword<out name>
-						( ":=" | "=" )
-						| (. if (nameFound) Error("no positional argument after named argument"); .)
-					) Expr<out expr>	(. 	if (expr != null) { if(name == "") positional.Add(expr);
-											else { named.Add(new NamedArgumentExpression(name, expr) { StartLocation = startLocation, EndLocation = t.EndLocation }); name = ""; }
-											}
-										.)
-			}
-		)
-	]
-	")"
-	.
-
-/* Spec, 5. */
-AttributeSection<out AttributeSection section>
-	(.
-		string attributeTarget = "";
-		List<ASTAttribute> attributes = new List<ASTAttribute>();
-		ASTAttribute attribute;
-		Location startLocation = la.Location;
-	.) =
-	"<"
-	[ IF (IsLocalAttrTarget())
-		( "Event"		(. attributeTarget = "event";.)
-		| "Return"		(. attributeTarget = "return";.)
-		| Identifier
-			(.
-				string val = t.val.ToLower(System.Globalization.CultureInfo.InvariantCulture);
-				if (val != "field"	|| val != "method" ||
-					val != "module" || val != "param"  ||
-					val != "property" || val != "type")
-				Error("attribute target specifier (event, return, field," +
-						"method, module, param, property, or type) expected");
-				attributeTarget = t.val;
-			.)
-		) ":" 
-	]
-	Attribute<out attribute>	(. attributes.Add(attribute); .)
-	{ IF (NotFinalComma()) "," Attribute<out attribute> (. attributes.Add(attribute); .) }
-	[ "," ]
-	">"
-		(.
-			section = new AttributeSection {
-				AttributeTarget = attributeTarget,
-				Attributes = attributes,
-				StartLocation = startLocation,
-				EndLocation = t.EndLocation
-			};
-		.)
-	.
-
-/* 9.2.5 */
-FormalParameterList<.List<ParameterDeclarationExpression> parameter.>
-(. ParameterDeclarationExpression p; .)
-=
-	FormalParameter<out p>	(. if (p != null) parameter.Add(p); .)
-	{	","
-		FormalParameter<out p>	(. if (p != null) parameter.Add(p); .)
-	}
-.
-/* 9.2.5 */
-FormalParameter<out ParameterDeclarationExpression p>
-(.
-	AttributeSection section;
-	List<AttributeSection> attributes = new List<AttributeSection>();
-	TypeReference type = null;
-	ParamModifierList mod = new ParamModifierList(this);
-	Expression expr = null;
-	p = null;
-	ArrayList arrayModifiers = null;
-	Location startLocation = la.Location;
-.)
-=
-	{ AttributeSection<out section> (. attributes.Add(section); .) }
-	{ ParameterModifier<mod> }
-	Identifier (. string parameterName = t.val; .)
-	[ IF(IsDims()) ArrayTypeModifiers<out arrayModifiers> ]
-	[ "As" TypeName<out type> ]
-	(.
-		if(type != null) {
-			if (arrayModifiers != null) {
-				if (type.RankSpecifier != null) {
-					Error("array rank only allowed one time");
-				} else {
-					type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int));
-				}
-			}
-		}
-	.)
-	[ "=" Expr<out expr> ]
-	(.
-		mod.Check();
-		p = new ParameterDeclarationExpression(type, parameterName, mod.Modifier, expr);
-		p.Attributes = attributes;
-		p.StartLocation = startLocation;
-		p.EndLocation = t.EndLocation;
-	.)
-.
-
-/* 10.1 */
-Block<out Statement stmt>
-	=
-	(.
-		BlockStatement blockStmt = new BlockStatement();
-		/* in snippet parsing mode, t might be null */
-		if (t != null) blockStmt.StartLocation = t.EndLocation;
-		BlockStart(blockStmt);
-	.)
-	{
-		IF (IsEndStmtAhead() || StartOf(StatementEndOfStmt))
-		(
-			"End" 
-			(. Token first = t;
-				AddChild(new EndStatement() {
-					StartLocation = first.Location,
-					EndLocation = first.EndLocation }
-				);
-			.) EndOfStmt
-			|
-			 (.NamedFirstSet:StatementEndOfStmt.) Statement EndOfStmt
-		)
-	}
-	(.
-		stmt = blockStmt;
-		if (t != null) blockStmt.EndLocation = t.EndLocation;
-		BlockEnd();
-	.)
-.
-
-Statement
-	(.
-		Statement stmt = null;
-		Location startPos = la.Location;
-		string label = String.Empty;
-	.) =
-	(
-		IF (IsLabel()) LabelName<out label>
-		(.
-			AddChild(new LabelStatement(t.val));
-		.)
-		":" Statement
-		| EmbeddedStatement<out stmt>			(. AddChild(stmt); .)
-	)
-	(.
-		if (stmt != null) {
-			stmt.StartLocation = startPos;
-			stmt.EndLocation = t.Location;
-		}
-	.)
-.
-
-/* 10.2 */
-LocalDeclarationStatement<out Statement statement>
-	(.
-		ModifierList m = new ModifierList();
-		LocalVariableDeclaration localVariableDeclaration;
-		bool dimfound = false;
-	.) =
-	/* this differs from the spec: dim static x	compiles with vbc. */
-	{
-		"Const" 	(. m.Add(Modifiers.Const, t.Location); .)
-		| "Static"	(. m.Add(Modifiers.Static, t.Location); .)
-		| "Dim"		(. dimfound = true; .)
-	}
-	(.
-		if(dimfound && (m.Modifier & Modifiers.Const) != 0) {
-			Error("Dim is not allowed on constants.");
-		}
-		
-		if(m.isNone && dimfound == false) {
-			Error("Const, Dim or Static expected");
-		}
-		
-		localVariableDeclaration = new LocalVariableDeclaration(m.Modifier);
-		localVariableDeclaration.StartLocation = t.Location;
-	.)
-	VariableDeclarator<localVariableDeclaration.Variables>
-	{ "," VariableDeclarator<localVariableDeclaration.Variables> }
-	(.
-		statement = localVariableDeclaration;
-	.)
-.
-
-EmbeddedStatement<out Statement statement>
-	(.
-		statement = null;
-		string name = String.Empty;
-		Location startLocation = la.Location;
-	.) =
-	( ExitStatement<out statement>
-	| TryStatement<out statement>
-	| ContinueStatement<out statement>
-	| ThrowStatement<out statement>
-	| ReturnStatement<out statement>
-	| SyncLockStatement<out statement>
-	| RaiseEventStatement<out statement>
-	| WithStatement<out statement>
-	| AddHandlerStatement<out statement>
-	| RemoveHandlerStatement<out statement>
-	| WhileStatement<out statement>
-	| DoLoopStatement<out statement>
-	| ForStatement<out statement>
-	| ErrorStatement<out statement>
-	| ReDimStatement<out statement>
-	| EraseStatement<out statement>
-	| StopStatement<out statement>
-	| IfStatement<out statement>
-	| SelectStatement<out statement>
-	| (. OnErrorStatement onErrorStatement = null; .)
-	OnErrorStatement<out onErrorStatement> (. statement = onErrorStatement; .)
-	| (. GotoStatement goToStatement = null; .)
-	GotoStatement<out goToStatement> (. statement = goToStatement; .)
-	| ResumeStatement<out statement>
-	| ExpressionStatement<out statement>
-	| InvocationStatement<out statement>
-	| UsingStatement<out statement>
-	| LocalDeclarationStatement<out statement>
-)
-(.
-	if (statement != null) {
-		statement.StartLocation = startLocation;
-		statement.EndLocation = t.EndLocation;
-	}
-.)
-.
-
-ExitStatement<out Statement statement> = 
-	"Exit"			(. ExitType exitType = ExitType.None; .)
-	( "Sub"		(. exitType = ExitType.Sub; .)
-	| "Function"	(. exitType = ExitType.Function; .)
-	| "Property"	(. exitType = ExitType.Property; .)
-	| "Do"			(. exitType = ExitType.Do; .)
-	| "For"		(. exitType = ExitType.For; .)
-	| "Try"		(. exitType = ExitType.Try; .)
-	| "While"		(. exitType = ExitType.While; .)
-	| "Select"		(. exitType = ExitType.Select; .) )
-	(. statement = new ExitStatement(exitType); .)
-.
-
-ContinueStatement<out Statement statement> =
-	"Continue" (. ContinueType continueType = ContinueType.None; .)
-	[ "Do" (. continueType = ContinueType.Do; .)
-	| "For" (. continueType = ContinueType.For; .)
-	| "While" (. continueType = ContinueType.While; .) ]
-	(. statement = new ContinueStatement(continueType); .)
-.
-
-ThrowStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"Throw" [ Expr<out expr> ] (. statement = new ThrowStatement(expr); .)
-.
-
-ReturnStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"Return" [ Expr<out expr> ] (. statement = new ReturnStatement(expr); .)
-.
-
-SyncLockStatement<out Statement statement>
-(. Expression expr; Statement embeddedStatement; .)
-=
-	"SyncLock" Expr<out expr> EndOfStmt
-		Block<out embeddedStatement>
-	"End" "SyncLock"
-	(. statement = new LockStatement(expr, embeddedStatement); .)
-.
-
-RaiseEventStatement<out Statement statement>
-(. List<Expression> arguments = null; .)
-=
-	"RaiseEvent" Identifier (. string name = t.val; .)
-	[ "(" ArgumentList<out arguments> ")" ]
-	(. statement = new RaiseEventStatement(name, arguments); .)
-.
-
-AddHandlerStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-/* 10.5.2 */
-	"AddHandler" (. Expression handlerExpr = null; .)
-	Expr<out expr> "," Expr<out handlerExpr>
-	(. statement = new AddHandlerStatement(expr, handlerExpr); .)
-.
-
-RemoveHandlerStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"RemoveHandler" (. Expression handlerExpr = null; .)
-	Expr<out expr> "," Expr<out handlerExpr>
-	(. statement = new RemoveHandlerStatement(expr, handlerExpr); .)
-.
-
-WhileStatement<out Statement statement>
-(. Expression expr = null; Statement embeddedStatement; .)
-=
-	"While" Expr<out expr> EndOfStmt
-	Block<out embeddedStatement> "End" "While"
-	(. statement = new DoLoopStatement(expr, embeddedStatement, ConditionType.While, ConditionPosition.Start); .)
-.
-
-DoLoopStatement<out Statement statement>
-(. Expression expr = null; Statement embeddedStatement; statement = null; .)
-=
-	"Do"
-	(. ConditionType conditionType = ConditionType.None; .)
-	(
-		WhileOrUntil<out conditionType> Expr<out expr> EndOfStmt
-		Block<out embeddedStatement>
-		"Loop"
-		(.
-			statement = new DoLoopStatement(expr, 
-			                                embeddedStatement, 
-			                                conditionType == ConditionType.While ? ConditionType.DoWhile : conditionType, 
-			                                ConditionPosition.Start);
-		.)
-		|
-		EndOfStmt
-		Block<out embeddedStatement>
-		"Loop" [WhileOrUntil<out conditionType> Expr<out expr>]
-		(. statement = new DoLoopStatement(expr, embeddedStatement, conditionType, ConditionPosition.End); .)
-	)
-.
-
-ForStatement<out Statement statement>
-(. Expression expr = null; Statement embeddedStatement; statement = null; Location startLocation = la.Location; .)
-=
-"For"
-	(.
-			Expression group = null;
-			TypeReference typeReference;
-			string        typeName;
-	.)
-	(
-		/* 10.9.3  */
- 		"Each" LoopControlVariable<out typeReference, out typeName>
-		"In" Expr<out group> EndOfStmt
-		Block<out embeddedStatement>
-		"Next" [ Expr<out expr> ]
-		(.
-			statement = new ForeachStatement(typeReference, 
-			                                 typeName,
-			                                 group, 
-			                                 embeddedStatement, 
-			                                 expr);
-			statement.StartLocation = startLocation;
-			statement.EndLocation   = t.EndLocation;
-			
-		.)
-		| /* 10.9.2 */
-		(.
-			Expression start = null;
-			Expression end = null;
-			Expression step = null;
-			Expression variableExpr = null;
-			Expression nextExpr = null;
-			List<Expression> nextExpressions = null;
-		.)
-		(	IF (IsLoopVariableDeclaration())
-			LoopControlVariable<out typeReference, out typeName>
-		|
-			(. typeReference = null; typeName = null; .)
-			SimpleExpr<out variableExpr>
-		)
-		"=" Expr<out start> "To" Expr<out end> [ "Step" Expr<out step> ]
-		EndOfStmt Block<out embeddedStatement>
-		"Next"
-		[
-			Expr<out nextExpr>
-			(.
-				nextExpressions = new List<Expression>();
-				nextExpressions.Add(nextExpr);
-			.)
-			{ "," Expr<out nextExpr> (. nextExpressions.Add(nextExpr); .) }
-		]
-		(.
-			statement = new ForNextStatement {
-				TypeReference = typeReference,
-				VariableName = typeName, 
-				LoopVariableExpression = variableExpr,
-				Start = start, 
-				End = end, 
-				Step = step, 
-				EmbeddedStatement = embeddedStatement, 
-				NextExpressions = nextExpressions
-			};
-		.)
-	)
-.
-
-ErrorStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"Error" Expr<out expr>
-	(. statement = new ErrorStatement(expr); .)
-.
-
-ReDimStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"ReDim" (. bool isPreserve = false; .)
-	[ EXPECTEDCONFLICT("Preserve") "Preserve" (. isPreserve = true; .) ]
-	ReDimClause<out expr>
-	(.
-		ReDimStatement reDimStatement = new ReDimStatement(isPreserve);
-		statement = reDimStatement;
-		SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression);
-	.)
-	{ "," ReDimClause<out expr>
-		(. SafeAdd(reDimStatement, reDimStatement.ReDimClauses, expr as InvocationExpression); .)
-	}
-.
-
-EraseStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"Erase"
-	Expr<out expr>
-	(.
-		EraseStatement eraseStatement = new EraseStatement();
-		if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr);}
-	.)
-	{ "," Expr<out expr> (. if (expr != null) { SafeAdd(eraseStatement, eraseStatement.Expressions, expr); }.) }
-	(. statement = eraseStatement; .)
-.
-
-StopStatement<out Statement statement> =
-	"Stop" (. statement = new StopStatement(); .)
-.
-
-IfStatement<out Statement statement>
-(. Expression expr = null; Statement embeddedStatement; statement = null; .)
-=
-	"If" (. Location ifStartLocation = t.Location; .) Expr<out expr> [ "Then" ] 
-	(	
-		/* multiline if statement */
-		EndOfStmt Block<out embeddedStatement>
-		(.
-			IfElseStatement ifStatement = new IfElseStatement(expr, embeddedStatement);
-			ifStatement.StartLocation = ifStartLocation;
-			Location elseIfStart;
-		.)
-		{
-			(
-				IF(IsElseIf()) "Else" (. elseIfStart = t.Location; .)  "If"
-				| "ElseIf" (. elseIfStart = t.Location; .)
-			)
-			(. Expression condition = null; Statement block = null; .)
-			Expr<out condition> [ "Then"] EndOfStmt
-			Block<out block>
-			(.
-				ElseIfSection elseIfSection = new ElseIfSection(condition, block);
-				elseIfSection.StartLocation = elseIfStart;
-				elseIfSection.EndLocation = t.Location;
-				elseIfSection.Parent = ifStatement;
-				ifStatement.ElseIfSections.Add(elseIfSection);
-			.)
-		}
-		[
-			"Else" [EndOfStmt]
-			Block<out embeddedStatement>
-			(.
-				ifStatement.FalseStatement.Add(embeddedStatement);
-			.)
-		] "End" "If"
-		(.
-			ifStatement.EndLocation = t.Location;
-			statement = ifStatement;
-		.)
-	|	/* singleline if statement */
-		(.
-			IfElseStatement ifStatement = new IfElseStatement(expr);
-			ifStatement.StartLocation = ifStartLocation;
-		.)
-		SingleLineStatementList<ifStatement.TrueStatement>
-		[
-			"Else"
-			[ SingleLineStatementList<ifStatement.FalseStatement> ]
-		]
-		(. ifStatement.EndLocation = t.Location; statement = ifStatement; .)
-	)
-.
-
-SelectStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"Select" [ "Case" ] Expr<out expr> EndOfStmt
-	(.List<SwitchSection> selectSections = new List<SwitchSection>();
-		Statement block = null;
-	.)
-	{
-		(.List<CaseLabel> caseClauses = null; Location caseLocation = la.Location; .)
-		"Case" CaseClauses<out caseClauses> [ IF(IsNotStatementSeparator()) ":" ] EndOfStmt
-		(.
-			SwitchSection selectSection = new SwitchSection(caseClauses);
-			selectSection.StartLocation = caseLocation;
-		.)
-		Block<out block>
-		(.
-			selectSection.Children = block.Children;
-			selectSection.EndLocation = t.EndLocation;
-			selectSections.Add(selectSection);
-		.)
-	}
-	(.
-		statement = new SwitchStatement(expr, selectSections);
-	.)
-	"End" "Select"
-.
-
-ExpressionStatement<out Statement statement>
-(. Expression expr = null; .)
-= /* Statement expression (invocation and assignment) 10.6.1, 10.6.2, 10.6.3 */
-	(.
-		Expression val = null;
-		AssignmentOperatorType op;
-		Location startLoc = la.Location;
-		
-		bool mustBeAssignment = la.kind == Tokens.Plus  || la.kind == Tokens.Minus ||
-		                        la.kind == Tokens.Not   || la.kind == Tokens.Times;
-	.)
-	SimpleExpr<out expr>
-		(
-		AssignmentOperator<out op> Expr<out val>
-		(.
-			expr = new AssignmentExpression(expr, op, val);
-			expr.StartLocation = startLoc;
-			expr.EndLocation = t.EndLocation;
-		.)
-		| (. if (mustBeAssignment) Error("error in assignment."); .)
-		)
-		(.
-			// a field reference expression that stands alone is a
-			// invocation expression without parantheses and arguments
-			if(expr is MemberReferenceExpression || expr is IdentifierExpression) {
-				Location endLocation = expr.EndLocation;
-				expr = new InvocationExpression(expr);
-				expr.StartLocation = startLoc;
-				expr.EndLocation = endLocation;
-			}
-			statement = new ExpressionStatement(expr);
-		.)
-.
-
-InvocationStatement<out Statement statement>
-(. Expression expr = null; .)
-=
-	"Call" SimpleExpr<out expr> (. statement = new ExpressionStatement(expr); .)
-.
-
-UsingStatement<out Statement statement>
-(. Expression expr = null; Statement block; statement = null; .)
-=
-	"Using"
-	(	IF (Peek(1).kind == Tokens.As)
-		(. LocalVariableDeclaration resourceAquisition = 
-			new LocalVariableDeclaration(Modifiers.None); .)
-		VariableDeclarator<resourceAquisition.Variables>
-		{ "," VariableDeclarator<resourceAquisition.Variables> }
-		EndOfStmt
-		Block<out block>
-		(. statement = new UsingStatement(resourceAquisition, block); .)
-	|	Expr<out expr>
-		EndOfStmt
-		Block<out block>
-		(. statement = new UsingStatement(new ExpressionStatement(expr), block); .)
-	)
-	"End" "Using"
-.
-
-SingleLineStatementList<.List<Statement> list.>
-(. Statement embeddedStatement = null; .)
-=
-	( "End" (. embeddedStatement = new EndStatement() { StartLocation = t.Location, EndLocation = t.EndLocation }; .)
-	| EmbeddedStatement<out embeddedStatement> )
-	(. if (embeddedStatement != null) list.Add(embeddedStatement); .)
-	{	":" { ":" }
-		( "End" (. embeddedStatement = new EndStatement() { StartLocation = t.Location, EndLocation = t.EndLocation }; .)
-		| EmbeddedStatement<out embeddedStatement> )
-		(. if (embeddedStatement != null) list.Add(embeddedStatement); .)
-	}
-.
-
-/* 10.9.2 */
-LoopControlVariable<out TypeReference type, out string name>
-(.ArrayList arrayModifiers = null;
-	type = null;
-.)
-=
-	Qualident<out name>
-	[ IF(IsDims()) ArrayTypeModifiers<out arrayModifiers> ]
-	[ "As" TypeName<out type> (. if (name.IndexOf('.') > 0) { Error("No type def for 'for each' member indexer allowed."); } .) ]
-	(.
-		if (type != null) {
-			if(type.RankSpecifier != null && arrayModifiers != null) {
-				Error("array rank only allowed one time");
-			} else if (arrayModifiers != null) {
-				type.RankSpecifier = (int[])arrayModifiers.ToArray(typeof(int));
-			}
-		}
-	.)
-.
-
-/* 10.2.2 */
-OnErrorStatement<out OnErrorStatement stmt>
-	(.
-		stmt = null;
-		Location startLocation = la.Location;
-		GotoStatement goToStatement = null;
-	.)
-	=
-	"On" "Error"
-	(
-		IF(IsNegativeLabelName())"GoTo" "-" LiteralInteger
-		(.
-			long intLabel = Int64.Parse(t.val);
-			if(intLabel != 1) {
-				Error("invalid label in on error statement.");
-			}
-			stmt = new OnErrorStatement(new GotoStatement((intLabel * -1).ToString()));
-		.)
-		| GotoStatement<out goToStatement>
-		(.
-			string val = goToStatement.Label;
-			
-			// if value is numeric, make sure that is 0
-			try {
-				long intLabel = Int64.Parse(val);
-				if(intLabel != 0) {
-					Error("invalid label in on error statement.");
-				}
-			} catch {
-			}
-			stmt = new OnErrorStatement(goToStatement);
-		.)
-		| "Resume" "Next"
-		(.
-			stmt = new OnErrorStatement(new ResumeStatement(true));
-		.)
-	)
-	(.
-		if (stmt != null) {
-			stmt.StartLocation = startLocation;
-			stmt.EndLocation = t.EndLocation;
-		}
-	.)
-	.
-
-/* 10.11 */
-GotoStatement<out GotoStatement goToStatement>
+VB =
 (.
-	string label = string.Empty;
-	Location startLocation = la.Location;
+	compilationUnit = new CompilationUnit();
+	NodeStart(compilationUnit);
+	Get();
 .)
-=
-	"GoTo" LabelName<out label>
-	(.
-		goToStatement = new GotoStatement(label) {
-			StartLocation = startLocation,
-			EndLocation = t.EndLocation
-		};
-	.)
+	{ StatementTerminator }
+	{ OptionStatement<CompilationUnit.MemberRole> { StatementTerminator } }
+	{ ImportsStatement<CompilationUnit.MemberRole> { StatementTerminator } }
+/*	{ IF (IsGlobalAttrTarget()) GlobalAttributeSection { StatementTerminator } }
+	{ NamespaceMemberDecl { StatementTerminator } } */
 .
 
-/* 10.1 */
-LabelName<out string name>
-	(.
-		name = string.Empty;
-	.) =
-	Identifier 		(. name = t.val; .)
-	| LiteralInteger	(. name = t.val; .)
-.
+StatementTerminator = SYNC ( EOL<Roles.StatementTerminator> | ":"<Roles.StatementTerminator> ) .
 
-/* 12.12.1 */
-ReDimClause<out Expression expr>
-=
-	SimpleNonInvocationExpression<out expr>
-	ReDimClauseInternal<ref expr>
-.
-
-ReDimClauseInternal<ref Expression expr>
-(. List<Expression> arguments; bool canBeNormal; bool canBeRedim; string name; Location startLocation = la.Location; .)
-=
-	{ "." IdentifierOrKeyword<out name> (. expr = new MemberReferenceExpression(expr, name) { StartLocation = startLocation, EndLocation = t.EndLocation }; .)
-	|  IF (la.kind == Tokens.OpenParenthesis && Peek(1).kind == Tokens.Of)
-		InvocationExpression<ref expr>
-		(.
-			expr.StartLocation = startLocation;
-			expr.EndLocation = t.EndLocation;
-		.)
-	}
-	"("
-	NormalOrReDimArgumentList<out arguments, out canBeNormal, out canBeRedim>
-	")"
-	(.	expr = new InvocationExpression(expr, arguments);
-		if (canBeRedim == false || canBeNormal && (la.kind == Tokens.Dot || la.kind == Tokens.OpenParenthesis)) {
-			if (this.Errors.Count == 0) {
-				// don't recurse on parse errors - could result in endless recursion
-				ReDimClauseInternal(ref expr);
-			}
-		}
-	.)
-.
-
-/* 10.10.2.3 */
-ResumeStatement<out Statement resumeStatement>
-(.
-	resumeStatement = null;
-	string label = string.Empty;
-.)
-=
-	"Resume"
-	[ "Next" (. resumeStatement = new ResumeStatement(true); .) | LabelName<out label> ]
-	// if only "Resume" is present label is ""
-	(. resumeStatement = new ResumeStatement(label); .)
-.
-
-/* 18.8.2 */
-CaseClauses<.out List<CaseLabel> caseClauses.>
-	(.
-		caseClauses = new List<CaseLabel>();
-		CaseLabel caseClause = null;
-	.) =
-	CaseClause<out caseClause> (. if (caseClause != null) { caseClauses.Add(caseClause); } .)
-	{ "," CaseClause<out caseClause> (. if (caseClause != null) { caseClauses.Add(caseClause); } .) }
-	.
-
-/* 19.8.2 */
-CaseClause<out CaseLabel caseClause>
-	(.
-		Expression expr = null;
-		Expression sexpr = null;
-		BinaryOperatorType op = BinaryOperatorType.None;
-		caseClause = null;
-	.) =
-	"Else"
-	(. caseClause = new CaseLabel(); .)
-	|
-	[ "Is" ] 
-	(
-		"<"		(. op = BinaryOperatorType.LessThan; .)
-		| ">"	(. op = BinaryOperatorType.GreaterThan; .)
-		| "<="	(. op = BinaryOperatorType.LessThanOrEqual; .)
-		| ">="	(. op = BinaryOperatorType.GreaterThanOrEqual; .)
-		| "="	(. op = BinaryOperatorType.Equality; .)
-		| "<>"	(. op = BinaryOperatorType.InEquality; .)
-	)
-	Expr<out expr>
-	(.
-		caseClause = new CaseLabel(op, expr);
-	.)
-	| Expr<out expr> [ "To" Expr<out sexpr> ]
-	(.
-		caseClause = new CaseLabel(expr, sexpr);
-	.)
-	.
-
-/* 10.9.1 */
-WhileOrUntil<out ConditionType conditionType>
-	(. conditionType = ConditionType.None; .) =
-	"While"		(. conditionType = ConditionType.While; .)
-	| "Until"	(. conditionType = ConditionType.Until; .)
-	.
+#region Identifier
 
-/* 10.3 */
-WithStatement<out Statement withStatement>
-	(.
-		Statement blockStmt = null;
-		Expression expr = null;
-	.) =
-	"With" (. Location start = t.Location; .)
-	Expr<out expr> EndOfStmt
-	(.
-		withStatement = new WithStatement(expr);
-		withStatement.StartLocation = start;
-	.)
-	Block<out blockStmt>
-	(.
-		((WithStatement)withStatement).Body = (BlockStatement)blockStmt;
-	.)
-	"End" "With"
-	(. withStatement.EndLocation = t.Location; .)
-	.
-	
-/* 10.10.1 */
-TryStatement<out Statement tryStatement>
-(.
-	Statement blockStmt = null;
-	Statement finallyStmt = null;
-	CatchClause clause = null;
-	List<CatchClause> catchClauses = new List<CatchClause>();
-.)
-=
-	"Try" EndOfStmt
-		Block<out blockStmt>
-		{ CatchClause<out clause> (. if (clause != null) catchClauses.Add(clause); .) }
-		["Finally" EndOfStmt Block<out finallyStmt> ]
-	"End" "Try"
-	(. tryStatement = new TryCatchStatement(blockStmt, catchClauses, finallyStmt); .)
-.
-
-/* 10.10.1.2 */
-CatchClause<out CatchClause catchClause>
-(.
-	TypeReference type = null;
-	Statement blockStmt = null;
-	Expression expr = null;
-	string name = String.Empty;
-.)
-=
-	"Catch"
-	[ Identifier (. name = t.val; .) ["As" TypeName<out type>] ]
-	[ "When" Expr<out expr> ]
-	EndOfStmt
-	Block<out blockStmt>
-	(. catchClause = new CatchClause(type, name, blockStmt, expr); .)
-.
-
-/* 4.7 */
-Qualident<out string qualident>
-(. 
-	string name;
-	qualidentBuilder.Length = 0; 
-.)
-=
-	Identifier	(. qualidentBuilder.Append(t.val); .)
-	{ IF (DotAndIdentOrKw()) "." IdentifierOrKeyword<out name> (. qualidentBuilder.Append('.'); qualidentBuilder.Append(name); .) }
-	
-	(. qualident = qualidentBuilder.ToString(); .)
-.
+//IdentifierOrKeyword<out string identifier> = ANY (. identifier = t.val; .) .
 
-/* This production handles pseudo keywords that are needed in the grammar */
+// This production handles pseudo keywords that are needed in the grammar
 Identifier	=
 	IdentifierForFieldDeclaration
-	| "Custom" 
+	| "Custom"
 .
 
 IdentifierForFieldDeclaration =
@@ -3735,32 +318,38 @@ IdentifierForFieldDeclaration =
 	| "Until"
 	| "Where"
 .
-
-/* 2.2 */
-IdentifierOrKeyword<out string name> =
-	ANY (. name = t.val;  .)
-.
-
-/* 7.3 */
-PrimitiveTypeName<out string type>
-	(. type = String.Empty; .) =
-	"Boolean"		(. type = "System.Boolean"; .)
-	| "Date"		(. type = "System.DateTime"; .)
-	| "Char"		(. type = "System.Char"; .)
-	| "String"		(. type = "System.String"; .)
-	| "Decimal"		(. type = "System.Decimal"; .)
-	| "Byte"		(. type = "System.Byte"; .)
-	| "Short"		(. type = "System.Int16"; .)
-	| "Integer"		(. type = "System.Int32"; .)
-	| "Long"		(. type = "System.Int64"; .)
-	| "Single"		(. type = "System.Single"; .)
-	| "Double"		(. type = "System.Double"; .)
-	| "UInteger"	(. type = "System.UInt32"; .)
-	| "ULong"		(. type = "System.UInt64"; .)
-	| "UShort"		(. type = "System.UInt16"; .)
-	| "SByte"		(. type = "System.SByte"; .)
-	.
-
+#endregion
+
+TypeName<out AstType type> (. type = null; .) =
+	PrimitiveTypeName<out type> |
+	QualifiedTypeName<out type>
+.
+QualifiedTypeName<out AstType type> =
+	( "Global" | Identifier ) (. type = new SimpleType(t.val, t.Location); .)
+	{ "." Identifier (. type = new QualifiedType(type, new Identifier(t.val, t.Location)); .) }
+	// TODO : add TypeArguments
+.
+
+PrimitiveTypeName<out AstType type> (. type = null; .) =
+	"Object"		(. type = new PrimitiveType("Object", t.Location); .)
+	| "Boolean"	(. type = new PrimitiveType("Boolean", t.Location); .)
+	| "Date"		(. type = new PrimitiveType("Date", t.Location); .)
+	| "Char"		(. type = new PrimitiveType("Char", t.Location); .)
+	| "String"		(. type = new PrimitiveType("String", t.Location); .)
+	| "Decimal"	(. type = new PrimitiveType("Decimal", t.Location); .)
+	| "Byte"		(. type = new PrimitiveType("Byte", t.Location); .)
+	| "Short"		(. type = new PrimitiveType("Short", t.Location); .)
+	| "Integer"	(. type = new PrimitiveType("Integer", t.Location); .)
+	| "Long"		(. type = new PrimitiveType("Long", t.Location); .)
+	| "Single"		(. type = new PrimitiveType("Single", t.Location); .)
+	| "Double"		(. type = new PrimitiveType("Double", t.Location); .)
+	| "UInteger"	(. type = new PrimitiveType("UInteger", t.Location); .)
+	| "ULong"		(. type = new PrimitiveType("ULong", t.Location); .)
+	| "UShort"		(. type = new PrimitiveType("UShort", t.Location); .)
+	| "SByte"		(. type = new PrimitiveType("SByte", t.Location); .)
+.
+
+/*
 ParameterModifier<ParamModifierList m> =
 	"ByVal"			(. m.Add(ParameterModifiers.In); .)
 	| "ByRef"			(. m.Add(ParameterModifiers.Ref); .)
@@ -3811,5 +400,61 @@ PropertyAccessorAccessModifier<out Modifiers m> =
 	 |  "Private"   (. m |= Modifiers.Private; .)
 	}
 .
+*/
+#endregion
+
+#region Global
+
+#region OptionStatement
+
+OptionStatement<auto> =
+	"Option"<Roles.Keyword> (
+		"Explicit"<Ast.OptionStatement.OptionTypeRole> (. result.OptionType = OptionType.Explicit; .) [ OnOff<result> ]
+		| "Strict"<Ast.OptionStatement.OptionTypeRole> (. result.OptionType = OptionType.Strict; .) [ OnOff<result> ]
+		| "Infer"<Ast.OptionStatement.OptionTypeRole> (. result.OptionType = OptionType.Infer; .) [ OnOff<result> ]
+		| "Compare"<Ast.OptionStatement.OptionTypeRole> (. result.OptionType = OptionType.Compare; .) BinaryText<result>
+	) StatementTerminator
+.
+
+OnOff<OptionStatement os> =
+	"On"<Ast.OptionStatement.OptionValueRole> (. os.OptionValue = OptionValue.On; .)
+	| "Off"<Ast.OptionStatement.OptionValueRole> (. os.OptionValue  = OptionValue.Off; .)
+.
+
+BinaryText<OptionStatement os> =
+	"Text"<Ast.OptionStatement.OptionValueRole> (. os.OptionValue = OptionValue.Text; .)
+	| "Binary"<Ast.OptionStatement.OptionValueRole> (. os.OptionValue  = OptionValue.Binary; .)
+.
+
+#endregion
+
+#region ImportsStatement
+
+ImportsStatement<auto> =
+	"Imports"<Roles.Keyword> ImportsClause { "," ImportsClause } StatementTerminator
+.
+
+ImportsClause =
+	( IF (IsAliasImportsClause())
+		AliasImportsClause<Ast.ImportsStatement.ImportsClauseRole> |
+	MemberImportsClause<Ast.ImportsStatement.ImportsClauseRole> |
+	XmlNamespaceImportsClause<Ast.ImportsStatement.ImportsClauseRole> ) SYNC .
+
+AliasImportsClause<auto> (. AstType alias; .) =
+	// Type characters are not allowed in identifiers here
+	Identifier (. result.Name = new Identifier(t.val, t.Location); .) "=" TypeName<out alias> (. result.Alias = alias; .)
+.
+
+MemberImportsClause<auto> (. AstType member; .) =
+	TypeName<out member> (. result.Member = member; .)
+.
+
+XmlNamespaceImportsClause<auto> =
+	XmlOpenTag<Roles.XmlOpenTag> Identifier/*<Roles.XmlIdentifier>*/ "="<Roles.Assign> LiteralString/*<Roles.XmlLiteralString>*/ XmlCloseTag<Roles.XmlCloseTag>
+.
+
+#endregion
+
+#endregion
 
 END VB .
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/ParserFactory.cs b/NRefactory/ICSharpCode.NRefactory.VB/ParserFactory.cs
deleted file mode 100644
index 1deba96ce..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/ParserFactory.cs
+++ /dev/null
@@ -1,45 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.IO;
-using System.Text;
-using ICSharpCode.NRefactory.VB.Parser;
-
-namespace ICSharpCode.NRefactory.VB
-{
-	/// <summary>
-	/// Static helper class that constructs lexer and parser objects.
-	/// </summary>
-	public static class ParserFactory
-	{
-		public static VBLexer CreateLexer(TextReader textReader)
-		{
-			return new ICSharpCode.NRefactory.VB.Parser.VBLexer(textReader);
-		}
-		
-		public static VBLexer CreateLexer(TextReader textReader, VBLexerMemento state)
-		{
-			return new ICSharpCode.NRefactory.VB.Parser.VBLexer(textReader, state);
-		}
-		
-		public static VBParser CreateParser(TextReader textReader)
-		{
-			Parser.VBLexer lexer = CreateLexer(textReader);
-			return new ICSharpCode.NRefactory.VB.Parser.VBParser(lexer);
-		}
-		
-		public static VBParser CreateParser(string fileName)
-		{
-			return CreateParser(fileName, Encoding.UTF8);
-		}
-		
-		public static VBParser CreateParser(string fileName, Encoding encoding)
-		{
-			string ext = Path.GetExtension(fileName);
-			if (ext.Equals(".vb", StringComparison.OrdinalIgnoreCase))
-				return CreateParser(new StreamReader(fileName, encoding));
-			return null;
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/AbstractOutputFormatter.cs b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/AbstractOutputFormatter.cs
index f58ea108d..c69a56b12 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/AbstractOutputFormatter.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/AbstractOutputFormatter.cs
@@ -196,19 +196,19 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 			}
 		}
 		
-		public abstract void PrintComment(Comment comment, bool forceWriteInPreviousBlock);
-		
-		public virtual void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock)
-		{
-			if (!directive.Expression.IsNull) {
-//				CSharpOutputVisitor visitor = new CSharpOutputVisitor();
-//				directive.Expression.AcceptVisitor(visitor, null);
-//				WriteLineInPreviousLine(directive.Cmd + " " + visitor.Text, forceWriteInPreviousBlock);
-			} else if (string.IsNullOrEmpty(directive.Arg))
-				WriteLineInPreviousLine(directive.Cmd, forceWriteInPreviousBlock);
-			else
-				WriteLineInPreviousLine(directive.Cmd + " " + directive.Arg, forceWriteInPreviousBlock);
-		}
+//		public abstract void PrintComment(Comment comment, bool forceWriteInPreviousBlock);
+		
+//		public virtual void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock)
+//		{
+//			if (!directive.Expression.IsNull) {
+////				CSharpOutputVisitor visitor = new CSharpOutputVisitor();
+////				directive.Expression.AcceptVisitor(visitor, null);
+////				WriteLineInPreviousLine(directive.Cmd + " " + visitor.Text, forceWriteInPreviousBlock);
+//			} else if (string.IsNullOrEmpty(directive.Arg))
+//				WriteLineInPreviousLine(directive.Cmd, forceWriteInPreviousBlock);
+//			else
+//				WriteLineInPreviousLine(directive.Cmd + " " + directive.Arg, forceWriteInPreviousBlock);
+//		}
 		
 		public void PrintBlankLine(bool forceWriteInPreviousBlock)
 		{
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs
index ecac6596d..71ccb5d0f 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/IOutputAstVisitor.cs
@@ -7,26 +7,26 @@ using ICSharpCode.NRefactory.VB.Ast;
 
 namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 {
-	public interface IOutputDomVisitor : IAstVisitor
-	{
-		event Action<INode> BeforeNodeVisit;
-		event Action<INode> AfterNodeVisit;
-		
-		string Text {
-			get;
-		}
-		
-		Errors Errors {
-			get;
-		}
-		
-		AbstractPrettyPrintOptions Options {
-			get;
-		}
-		IOutputFormatter OutputFormatter {
-			get;
-		}
-	}
+//	public interface IOutputDomVisitor : IAstVisitor
+//	{
+//		event Action<INode> BeforeNodeVisit;
+//		event Action<INode> AfterNodeVisit;
+//		
+//		string Text {
+//			get;
+//		}
+//		
+//		Errors Errors {
+//			get;
+//		}
+//		
+//		AbstractPrettyPrintOptions Options {
+//			get;
+//		}
+//		IOutputFormatter OutputFormatter {
+//			get;
+//		}
+//	}
 	
 	public interface IOutputFormatter
 	{
@@ -43,8 +43,8 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 		}
 		void NewLine();
 		void Indent();
-		void PrintComment(Comment comment, bool forceWriteInPreviousBlock);
-		void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock);
+//		void PrintComment(Comment comment, bool forceWriteInPreviousBlock);
+//		void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock);
 		void PrintBlankLine(bool forceWriteInPreviousBlock);
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs
index 2dbc3faaa..95fdcf389 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/SpecialNodesInserter.cs
@@ -7,136 +7,136 @@ using ICSharpCode.NRefactory.VB.Ast;
 
 namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 {
-	public class SpecialOutputVisitor : ISpecialVisitor
-	{
-		readonly IOutputFormatter formatter;
-		
-		public SpecialOutputVisitor(IOutputFormatter formatter)
-		{
-			this.formatter = formatter;
-		}
-		
-		public bool ForceWriteInPreviousLine;
-		
-		public object Visit(ISpecial special, object data)
-		{
-			Console.WriteLine("Warning: SpecialOutputVisitor.Visit(ISpecial) called with " + special);
-			return data;
-		}
-		
-		public object Visit(BlankLine special, object data)
-		{
-			formatter.PrintBlankLine(ForceWriteInPreviousLine);
-			return data;
-		}
-		
-		public object Visit(Comment special, object data)
-		{
-			formatter.PrintComment(special, ForceWriteInPreviousLine);
-			return data;
-		}
-		
-		public object Visit(PreprocessingDirective special, object data)
-		{
-			formatter.PrintPreprocessingDirective(special, ForceWriteInPreviousLine);
-			return data;
-		}
-	}
-	
-	/// <summary>
-	/// This class inserts specials between INodes.
-	/// </summary>
-	public sealed class SpecialNodesInserter : IDisposable
-	{
-		IEnumerator<ISpecial> enumerator;
-		SpecialOutputVisitor visitor;
-		bool available; // true when more specials are available
-		
-		public SpecialNodesInserter(IEnumerable<ISpecial> specials, SpecialOutputVisitor visitor)
-		{
-			if (specials == null) throw new ArgumentNullException("specials");
-			if (visitor == null) throw new ArgumentNullException("visitor");
-			enumerator = specials.GetEnumerator();
-			this.visitor = visitor;
-			available = enumerator.MoveNext();
-		}
-		
-		void WriteCurrent()
-		{
-			enumerator.Current.AcceptVisitor(visitor, null);
-			available = enumerator.MoveNext();
-		}
-		
-		AttributedNode currentAttributedNode;
-		
-		/// <summary>
-		/// Writes all specials up to the start position of the node.
-		/// </summary>
-		public void AcceptNodeStart(INode node)
-		{
-			if (node is AttributedNode) {
-				currentAttributedNode = node as AttributedNode;
-				if (currentAttributedNode.Attributes.Count == 0) {
-					AcceptPoint(node.StartLocation);
-					currentAttributedNode = null;
-				}
-			} else {
-				AcceptPoint(node.StartLocation);
-			}
-		}
-		
-		/// <summary>
-		/// Writes all specials up to the end position of the node.
-		/// </summary>
-		public void AcceptNodeEnd(INode node)
-		{
-			visitor.ForceWriteInPreviousLine = true;
-			AcceptPoint(node.EndLocation);
-			visitor.ForceWriteInPreviousLine = false;
-			if (currentAttributedNode != null) {
-				if (node == currentAttributedNode.Attributes[currentAttributedNode.Attributes.Count - 1]) {
-					AcceptPoint(currentAttributedNode.StartLocation);
-					currentAttributedNode = null;
-				}
-			}
-		}
-		
-		/// <summary>
-		/// Writes all specials up to the specified location.
-		/// </summary>
-		public void AcceptPoint(Location loc)
-		{
-			while (available && enumerator.Current.StartPosition <= loc) {
-				WriteCurrent();
-			}
-		}
-		
-		/// <summary>
-		/// Outputs all missing specials to the writer.
-		/// </summary>
-		public void Finish()
-		{
-			while (available) {
-				WriteCurrent();
-			}
-		}
-		
-		void IDisposable.Dispose()
-		{
-			Finish();
-		}
-		
-		/// <summary>
-		/// Registers a new SpecialNodesInserter with the output visitor.
-		/// Make sure to call Finish() (or Dispose()) on the returned SpecialNodesInserter
-		/// when the output is finished.
-		/// </summary>
-		public static SpecialNodesInserter Install(IEnumerable<ISpecial> specials, IOutputDomVisitor outputVisitor)
-		{
-			SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
-			outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
-			outputVisitor.AfterNodeVisit  += sni.AcceptNodeEnd;
-			return sni;
-		}
-	}
+//	public class SpecialOutputVisitor : ISpecialVisitor
+//	{
+//		readonly IOutputFormatter formatter;
+//		
+//		public SpecialOutputVisitor(IOutputFormatter formatter)
+//		{
+//			this.formatter = formatter;
+//		}
+//		
+//		public bool ForceWriteInPreviousLine;
+//		
+//		public object Visit(ISpecial special, object data)
+//		{
+//			Console.WriteLine("Warning: SpecialOutputVisitor.Visit(ISpecial) called with " + special);
+//			return data;
+//		}
+//		
+//		public object Visit(BlankLine special, object data)
+//		{
+//			formatter.PrintBlankLine(ForceWriteInPreviousLine);
+//			return data;
+//		}
+//		
+//		public object Visit(Comment special, object data)
+//		{
+//			formatter.PrintComment(special, ForceWriteInPreviousLine);
+//			return data;
+//		}
+//		
+//		public object Visit(PreprocessingDirective special, object data)
+//		{
+//			formatter.PrintPreprocessingDirective(special, ForceWriteInPreviousLine);
+//			return data;
+//		}
+//	}
+//	
+//	/// <summary>
+//	/// This class inserts specials between INodes.
+//	/// </summary>
+//	public sealed class SpecialNodesInserter : IDisposable
+//	{
+//		IEnumerator<ISpecial> enumerator;
+//		SpecialOutputVisitor visitor;
+//		bool available; // true when more specials are available
+//		
+//		public SpecialNodesInserter(IEnumerable<ISpecial> specials, SpecialOutputVisitor visitor)
+//		{
+//			if (specials == null) throw new ArgumentNullException("specials");
+//			if (visitor == null) throw new ArgumentNullException("visitor");
+//			enumerator = specials.GetEnumerator();
+//			this.visitor = visitor;
+//			available = enumerator.MoveNext();
+//		}
+//		
+//		void WriteCurrent()
+//		{
+//			enumerator.Current.AcceptVisitor(visitor, null);
+//			available = enumerator.MoveNext();
+//		}
+//		
+//		AttributedNode currentAttributedNode;
+//		
+//		/// <summary>
+//		/// Writes all specials up to the start position of the node.
+//		/// </summary>
+//		public void AcceptNodeStart(INode node)
+//		{
+//			if (node is AttributedNode) {
+//				currentAttributedNode = node as AttributedNode;
+//				if (currentAttributedNode.Attributes.Count == 0) {
+//					AcceptPoint(node.StartLocation);
+//					currentAttributedNode = null;
+//				}
+//			} else {
+//				AcceptPoint(node.StartLocation);
+//			}
+//		}
+//		
+//		/// <summary>
+//		/// Writes all specials up to the end position of the node.
+//		/// </summary>
+//		public void AcceptNodeEnd(INode node)
+//		{
+//			visitor.ForceWriteInPreviousLine = true;
+//			AcceptPoint(node.EndLocation);
+//			visitor.ForceWriteInPreviousLine = false;
+//			if (currentAttributedNode != null) {
+//				if (node == currentAttributedNode.Attributes[currentAttributedNode.Attributes.Count - 1]) {
+//					AcceptPoint(currentAttributedNode.StartLocation);
+//					currentAttributedNode = null;
+//				}
+//			}
+//		}
+//		
+//		/// <summary>
+//		/// Writes all specials up to the specified location.
+//		/// </summary>
+//		public void AcceptPoint(Location loc)
+//		{
+//			while (available && enumerator.Current.StartPosition <= loc) {
+//				WriteCurrent();
+//			}
+//		}
+//		
+//		/// <summary>
+//		/// Outputs all missing specials to the writer.
+//		/// </summary>
+//		public void Finish()
+//		{
+//			while (available) {
+//				WriteCurrent();
+//			}
+//		}
+//		
+//		void IDisposable.Dispose()
+//		{
+//			Finish();
+//		}
+//		
+//		/// <summary>
+//		/// Registers a new SpecialNodesInserter with the output visitor.
+//		/// Make sure to call Finish() (or Dispose()) on the returned SpecialNodesInserter
+//		/// when the output is finished.
+//		/// </summary>
+//		public static SpecialNodesInserter Install(IEnumerable<ISpecial> specials, IOutputDomVisitor outputVisitor)
+//		{
+//			SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
+//			outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
+//			outputVisitor.AfterNodeVisit  += sni.AcceptNodeEnd;
+//			return sni;
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputFormatter.cs b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputFormatter.cs
index 5a565bcf9..ca2325bba 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputFormatter.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputFormatter.cs
@@ -31,37 +31,37 @@ namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 			}
 		}
 		
-		public override void PrintComment(Comment comment, bool forceWriteInPreviousBlock)
-		{
-			switch (comment.CommentType) {
-				case CommentType.Block:
-					WriteLineInPreviousLine("'" + comment.CommentText.Replace("\n", "\n'"), forceWriteInPreviousBlock);
-					break;
-				case CommentType.Documentation:
-					WriteLineInPreviousLine("'''" + comment.CommentText, forceWriteInPreviousBlock);
-					break;
-				default:
-					WriteLineInPreviousLine("'" + comment.CommentText, forceWriteInPreviousBlock);
-					break;
-			}
-		}
+//		public override void PrintComment(Comment comment, bool forceWriteInPreviousBlock)
+//		{
+//			switch (comment.CommentType) {
+//				case CommentType.Block:
+//					WriteLineInPreviousLine("'" + comment.CommentText.Replace("\n", "\n'"), forceWriteInPreviousBlock);
+//					break;
+//				case CommentType.Documentation:
+//					WriteLineInPreviousLine("'''" + comment.CommentText, forceWriteInPreviousBlock);
+//					break;
+//				default:
+//					WriteLineInPreviousLine("'" + comment.CommentText, forceWriteInPreviousBlock);
+//					break;
+//			}
+//		}
 		
-		public override void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock)
-		{
-			if (IsInMemberBody
-			    && (string.Equals(directive.Cmd, "#Region", StringComparison.InvariantCultureIgnoreCase)
-			        || string.Equals(directive.Cmd, "#End", StringComparison.InvariantCultureIgnoreCase)
-			        && directive.Arg.StartsWith("Region", StringComparison.InvariantCultureIgnoreCase)))
-			{
-				WriteLineInPreviousLine("'" + directive.Cmd + " " + directive.Arg, forceWriteInPreviousBlock);
-			} else if (!directive.Expression.IsNull) {
-				VBNetOutputVisitor visitor = new VBNetOutputVisitor();
-				directive.Expression.AcceptVisitor(visitor, null);
-				WriteLineInPreviousLine(directive.Cmd + " " + visitor.Text + " Then", forceWriteInPreviousBlock);
-			} else {
-				base.PrintPreprocessingDirective(directive, forceWriteInPreviousBlock);
-			}
-		}
+//		public override void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock)
+//		{
+//			if (IsInMemberBody
+//			    && (string.Equals(directive.Cmd, "#Region", StringComparison.InvariantCultureIgnoreCase)
+//			        || string.Equals(directive.Cmd, "#End", StringComparison.InvariantCultureIgnoreCase)
+//			        && directive.Arg.StartsWith("Region", StringComparison.InvariantCultureIgnoreCase)))
+//			{
+//				WriteLineInPreviousLine("'" + directive.Cmd + " " + directive.Arg, forceWriteInPreviousBlock);
+//			} else if (!directive.Expression.IsNull) {
+//				VBNetOutputVisitor visitor = new VBNetOutputVisitor();
+//				directive.Expression.AcceptVisitor(visitor, null);
+//				WriteLineInPreviousLine(directive.Cmd + " " + visitor.Text + " Then", forceWriteInPreviousBlock);
+//			} else {
+//				base.PrintPreprocessingDirective(directive, forceWriteInPreviousBlock);
+//			}
+//		}
 		
 		public void PrintLineContinuation()
 		{
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
index dbf5d2bc9..972c09260 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/PrettyPrinter/VBNet/VBNetOutputVisitor.cs
@@ -15,3009 +15,3009 @@ using ICSharpCode.NRefactory.VB.Visitors;
 
 namespace ICSharpCode.NRefactory.VB.PrettyPrinter
 {
-	public sealed class VBNetOutputVisitor : NodeTrackingAstVisitor, IOutputDomVisitor
-	{
-		Errors                  errors             = new Errors();
-		VBNetOutputFormatter    outputFormatter;
-		VBNetPrettyPrintOptions prettyPrintOptions = new VBNetPrettyPrintOptions();
-		TypeDeclaration         currentType;
-		
-		Stack<int> exitTokenStack = new Stack<int>();
-		
-		public string Text {
-			get {
-				return outputFormatter.Text;
-			}
-		}
-		
-		public Errors Errors {
-			get {
-				return errors;
-			}
-		}
-		
-		AbstractPrettyPrintOptions IOutputDomVisitor.Options {
-			get { return prettyPrintOptions; }
-		}
-		
-		public VBNetPrettyPrintOptions Options {
-			get { return prettyPrintOptions; }
-		}
-		
-		public IOutputFormatter OutputFormatter {
-			get {
-				return outputFormatter;
-			}
-		}
-		
-		public VBNetOutputVisitor()
-		{
-			outputFormatter = new VBNetOutputFormatter(prettyPrintOptions);
-		}
-		
-		public event Action<INode> BeforeNodeVisit;
-		public event Action<INode> AfterNodeVisit;
-		
-		protected override void BeginVisit(INode node)
-		{
-			if (BeforeNodeVisit != null) {
-				BeforeNodeVisit(node);
-			}
-			base.BeginVisit(node);
-		}
-		
-		protected override void EndVisit(INode node)
-		{
-			base.EndVisit(node);
-			if (AfterNodeVisit != null) {
-				AfterNodeVisit(node);
-			}
-		}
-		
-		object TrackedVisit(INode node, object data)
-		{
-			return node.AcceptVisitor(this, data);
-		}
-		
-		void Error(string text, Location position)
-		{
-			errors.Error(position.Line, position.Column, text);
-		}
-		
-		void UnsupportedNode(INode node)
-		{
-			Error(node.GetType().Name + " is unsupported", node.StartLocation);
-		}
-		
-		#region ICSharpCode.NRefactory.Parser.IAstVisitor interface implementation
-		public override object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data)
-		{
-			compilationUnit.AcceptChildren(this, data);
-			outputFormatter.EndFile();
-			return null;
-		}
-		
-		/// <summary>
-		/// Converts type name to primitive type name. Returns typeString if typeString is not
-		/// a primitive type.
-		/// </summary>
-		static string ConvertTypeString(string typeString)
-		{
-			string primitiveType;
-			if (TypeReference.PrimitiveTypesVBReverse.TryGetValue(typeString, out primitiveType))
-				return primitiveType;
-			else
-				return typeString;
-		}
-
-		public override object TrackedVisitTypeReference(TypeReference typeReference, object data)
-		{
-			if (typeReference == TypeReference.ClassConstraint) {
-				outputFormatter.PrintToken(Tokens.Class);
-			} else if (typeReference == TypeReference.StructConstraint) {
-				outputFormatter.PrintToken(Tokens.Structure);
-			} else if (typeReference == TypeReference.NewConstraint) {
-				outputFormatter.PrintToken(Tokens.New);
-			} else {
-				PrintTypeReferenceWithoutArray(typeReference);
-				if (typeReference.IsArrayType) {
-					PrintArrayRank(typeReference.RankSpecifier, 0);
-				}
-			}
-			return null;
-		}
-		
-		void PrintTypeReferenceWithoutArray(TypeReference typeReference)
-		{
-			if (typeReference.IsGlobal) {
-				outputFormatter.PrintToken(Tokens.Global);
-				outputFormatter.PrintToken(Tokens.Dot);
-			}
-			bool printGenerics = true;
-			if (typeReference.IsKeyword) {
-				outputFormatter.PrintText(ConvertTypeString(typeReference.Type));
-			} else {
-				outputFormatter.PrintIdentifier(typeReference.Type);
-			}
-			if (printGenerics && typeReference.GenericTypes != null && typeReference.GenericTypes.Count > 0) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				outputFormatter.PrintToken(Tokens.Of);
-				outputFormatter.Space();
-				AppendCommaSeparatedList(typeReference.GenericTypes);
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-			for (int i = 0; i < typeReference.PointerNestingLevel; ++i) {
-				outputFormatter.PrintToken(Tokens.Times);
-			}
-		}
-		
-		void PrintArrayRank(int[] rankSpecifier, int startRank)
-		{
-			for (int i = startRank; i < rankSpecifier.Length; ++i) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				for (int j = 0; j < rankSpecifier[i]; ++j) {
-					outputFormatter.PrintToken(Tokens.Comma);
-				}
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-		}
-		
-		public override object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
-		{
-			TrackedVisit(innerClassTypeReference.BaseType, data);
-			outputFormatter.PrintToken(Tokens.Dot);
-			return VisitTypeReference((TypeReference)innerClassTypeReference, data);
-		}
-		
-		#region Global scope
-		bool printAttributeSectionInline; // is set to true when printing parameter's attributes
-		
-		public override object TrackedVisitAttributeSection(AttributeSection attributeSection, object data)
-		{
-			if (!printAttributeSectionInline)
-				outputFormatter.Indent();
-			outputFormatter.PrintText("<");
-			if (!string.IsNullOrEmpty(attributeSection.AttributeTarget) && !string.Equals(attributeSection.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase)) {
-				outputFormatter.PrintText(char.ToUpperInvariant(attributeSection.AttributeTarget[0]) + attributeSection.AttributeTarget.Substring(1));
-				outputFormatter.PrintToken(Tokens.Colon);
-				outputFormatter.Space();
-			}
-			Debug.Assert(attributeSection.Attributes != null);
-			AppendCommaSeparatedList(attributeSection.Attributes);
-			
-			outputFormatter.PrintText(">");
-			
-			if ("assembly".Equals(attributeSection.AttributeTarget, StringComparison.InvariantCultureIgnoreCase)
-			    || "module".Equals(attributeSection.AttributeTarget, StringComparison.InvariantCultureIgnoreCase)) {
-				outputFormatter.NewLine();
-			} else {
-				if (printAttributeSectionInline)
-					outputFormatter.Space();
-				else
-					outputFormatter.PrintLineContinuation();
-			}
-			
-			return null;
-		}
-		
-		public override object TrackedVisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data)
-		{
-			outputFormatter.PrintIdentifier(attribute.Name);
-			if (attribute.PositionalArguments.Count > 0 || attribute.NamedArguments.Count > 0) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				AppendCommaSeparatedList(attribute.PositionalArguments);
-				
-				if (attribute.NamedArguments.Count > 0) {
-					if (attribute.PositionalArguments.Count > 0) {
-						outputFormatter.PrintToken(Tokens.Comma);
-						outputFormatter.Space();
-					}
-					AppendCommaSeparatedList(attribute.NamedArguments);
-				}
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data)
-		{
-			outputFormatter.PrintIdentifier(namedArgumentExpression.Name);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Colon);
-			outputFormatter.PrintToken(Tokens.Assign);
-			outputFormatter.Space();
-			TrackedVisit(namedArgumentExpression.Expression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitUsing(Using @using, object data)
-		{
-			Debug.Fail("Should never be called. The usings should be handled in Visit(UsingDeclaration)");
-			return null;
-		}
-		
-		public override object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
-		{
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.Imports);
-			outputFormatter.Space();
-			for (int i = 0; i < usingDeclaration.Usings.Count; ++i) {
-				outputFormatter.PrintIdentifier(((Using)usingDeclaration.Usings[i]).Name);
-				if (((Using)usingDeclaration.Usings[i]).IsAlias) {
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.Assign);
-					outputFormatter.Space();
-					TrackedVisit(((Using)usingDeclaration.Usings[i]).Alias, data);
-				}
-				if (i + 1 < usingDeclaration.Usings.Count) {
-					outputFormatter.PrintToken(Tokens.Comma);
-					outputFormatter.Space();
-				}
-			}
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
-		{
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.Namespace);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(namespaceDeclaration.Name);
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			namespaceDeclaration.AcceptChildren(this, data);
-			--outputFormatter.IndentationLevel;
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Namespace);
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		static int GetTypeToken(TypeDeclaration typeDeclaration)
-		{
-			switch (typeDeclaration.Type) {
-				case ClassType.Class:
-					return Tokens.Class;
-				case ClassType.Enum:
-					return Tokens.Enum;
-				case ClassType.Interface:
-					return Tokens.Interface;
-				case ClassType.Struct:
-					return Tokens.Structure;
-				case ClassType.Module:
-					return Tokens.Module;
-				default:
-					return Tokens.Class;
-			}
-		}
-		
-		void PrintTemplates(List<TemplateDefinition> templates)
-		{
-			if (templates != null && templates.Count > 0) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				outputFormatter.PrintToken(Tokens.Of);
-				outputFormatter.Space();
-				AppendCommaSeparatedList(templates);
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-		}
-		
-		public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
-		{
-			VisitAttributes(typeDeclaration.Attributes, data);
-			
-			outputFormatter.Indent();
-			OutputModifier(typeDeclaration.Modifier, true, false);
-			
-			int typeToken = GetTypeToken(typeDeclaration);
-			outputFormatter.PrintToken(typeToken);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(typeDeclaration.Name);
-			
-			PrintTemplates(typeDeclaration.Templates);
-			
-			if (typeDeclaration.Type == ClassType.Enum
-			    && typeDeclaration.BaseTypes != null && typeDeclaration.BaseTypes.Count > 0)
-			{
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				foreach (TypeReference baseTypeRef in typeDeclaration.BaseTypes) {
-					TrackedVisit(baseTypeRef, data);
-				}
-			}
-			
-			outputFormatter.NewLine();
-			++outputFormatter.IndentationLevel;
-			
-			if (typeDeclaration.BaseTypes != null && typeDeclaration.Type != ClassType.Enum) {
-				foreach (TypeReference baseTypeRef in typeDeclaration.BaseTypes) {
-					outputFormatter.Indent();
-					
-					string baseType = baseTypeRef.Type;
-					if (baseType.IndexOf('.') >= 0) {
-						baseType = baseType.Substring(baseType.LastIndexOf('.') + 1);
-					}
-					bool baseTypeIsInterface = baseType.Length >= 2 && baseType[0] == 'I' && Char.IsUpper(baseType[1]);
-					
-					if (!baseTypeIsInterface || typeDeclaration.Type == ClassType.Interface) {
-						outputFormatter.PrintToken(Tokens.Inherits);
-					} else {
-						outputFormatter.PrintToken(Tokens.Implements);
-					}
-					outputFormatter.Space();
-					TrackedVisit(baseTypeRef, data);
-					outputFormatter.NewLine();
-				}
-			}
-			
-			TypeDeclaration oldType = currentType;
-			currentType = typeDeclaration;
-			
-			if (typeDeclaration.Type == ClassType.Enum) {
-				OutputEnumMembers(typeDeclaration, data);
-			} else {
-				typeDeclaration.AcceptChildren(this, data);
-			}
-			currentType = oldType;
-			
-			--outputFormatter.IndentationLevel;
-			
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(typeToken);
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		void OutputEnumMembers(TypeDeclaration typeDeclaration, object data)
-		{
-			foreach (FieldDeclaration fieldDeclaration in typeDeclaration.Children) {
-				BeginVisit(fieldDeclaration);
-				VariableDeclaration f = (VariableDeclaration)fieldDeclaration.Fields[0];
-				VisitAttributes(fieldDeclaration.Attributes, data);
-				outputFormatter.Indent();
-				outputFormatter.PrintIdentifier(f.Name);
-				if (f.Initializer != null && !f.Initializer.IsNull) {
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.Assign);
-					outputFormatter.Space();
-					TrackedVisit(f.Initializer, data);
-				}
-				outputFormatter.NewLine();
-				EndVisit(fieldDeclaration);
-			}
-		}
-		
-		public override object TrackedVisitTemplateDefinition(TemplateDefinition templateDefinition, object data)
-		{
-			VisitAttributes(templateDefinition.Attributes, data);
-			switch (templateDefinition.VarianceModifier) {
-				case VarianceModifier.Invariant:
-					// nothing
-					break;
-				case VarianceModifier.Covariant:
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.Out);
-					outputFormatter.Space();
-					break;
-				case VarianceModifier.Contravariant:
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.In);
-					outputFormatter.Space();
-					break;
-				default:
-					throw new Exception("Invalid value for VarianceModifier");
-			}
-			outputFormatter.PrintIdentifier(templateDefinition.Name);
-			if (templateDefinition.Bases.Count > 0) {
-				outputFormatter.PrintText(" As ");
-				VisitReturnTypeAttributes(templateDefinition.Attributes, data);
-				if (templateDefinition.Bases.Count == 1) {
-					TrackedVisit(templateDefinition.Bases[0], data);
-				} else {
-					outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
-					AppendCommaSeparatedList(templateDefinition.Bases);
-					outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
-				}
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
-		{
-			VisitAttributes(delegateDeclaration.Attributes, data);
-			
-			outputFormatter.Indent();
-			OutputModifier(delegateDeclaration.Modifier, true, false);
-			outputFormatter.PrintToken(Tokens.Delegate);
-			outputFormatter.Space();
-			
-			bool isFunction = (delegateDeclaration.ReturnType.Type != "System.Void");
-			if (isFunction) {
-				outputFormatter.PrintToken(Tokens.Function);
-				outputFormatter.Space();
-			} else {
-				outputFormatter.PrintToken(Tokens.Sub);
-				outputFormatter.Space();
-			}
-			outputFormatter.PrintIdentifier(delegateDeclaration.Name);
-			
-			PrintTemplates(delegateDeclaration.Templates);
-			
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(delegateDeclaration.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			if (isFunction) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				VisitReturnTypeAttributes(delegateDeclaration.Attributes, data);
-				TrackedVisit(delegateDeclaration.ReturnType, data);
-			}
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitOptionDeclaration(OptionDeclaration optionDeclaration, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Option);
-			outputFormatter.Space();
-			switch (optionDeclaration.OptionType) {
-				case OptionType.Strict:
-					outputFormatter.PrintToken(Tokens.Strict);
-					outputFormatter.Space();
-					outputFormatter.PrintToken(optionDeclaration.OptionValue ? Tokens.On : Tokens.Off);
-					break;
-				case OptionType.Explicit:
-					outputFormatter.PrintToken(Tokens.Explicit);
-					outputFormatter.Space();
-					outputFormatter.PrintToken(optionDeclaration.OptionValue ? Tokens.On : Tokens.Off);
-					break;
-				case OptionType.Infer:
-					outputFormatter.PrintToken(Tokens.Infer);
-					outputFormatter.Space();
-					outputFormatter.PrintToken(optionDeclaration.OptionValue ? Tokens.On : Tokens.Off);
-					break;
-				case OptionType.CompareBinary:
-					outputFormatter.PrintToken(Tokens.Compare);
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.Binary);
-					break;
-				case OptionType.CompareText:
-					outputFormatter.PrintToken(Tokens.Compare);
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.Text);
-					break;
-			}
-			outputFormatter.NewLine();
-			return null;
-		}
-		#endregion
-		
-		#region Type level
-		TypeReference currentVariableType;
-		public override object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
-		{
-			
-			VisitAttributes(fieldDeclaration.Attributes, data);
-			outputFormatter.Indent();
-			if (fieldDeclaration.Modifier == Modifiers.None) {
-				outputFormatter.PrintToken(Tokens.Private);
-				outputFormatter.Space();
-			} else {
-				OutputModifier(fieldDeclaration.Modifier, false, true);
-			}
-			currentVariableType = fieldDeclaration.TypeReference;
-			AppendCommaSeparatedList(fieldDeclaration.Fields);
-			currentVariableType = null;
-			
-			outputFormatter.NewLine();
-
-			return null;
-		}
-		
-		public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
-		{
-			outputFormatter.PrintIdentifier(variableDeclaration.Name);
-			
-			TypeReference varType = currentVariableType;
-			if (varType != null && varType.IsNull)
-				varType = null;
-			if (varType == null && !variableDeclaration.TypeReference.IsNull)
-				varType = variableDeclaration.TypeReference;
-			
-			if (varType != null) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				ObjectCreateExpression init = variableDeclaration.Initializer as ObjectCreateExpression;
-				if (init != null && TypeReference.AreEqualReferences(init.CreateType, varType)) {
-					TrackedVisit(variableDeclaration.Initializer, data);
-					return null;
-				} else {
-					TrackedVisit(varType, data);
-				}
-			}
-			
-			if (!variableDeclaration.Initializer.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Assign);
-				outputFormatter.Space();
-				TrackedVisit(variableDeclaration.Initializer, data);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
-		{
-			VisitAttributes(propertyDeclaration.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(propertyDeclaration.Modifier);
-			
-			if ((propertyDeclaration.Modifier & (Modifiers.ReadOnly | Modifiers.WriteOnly)) == Modifiers.None) {
-				if (propertyDeclaration.IsReadOnly) {
-					outputFormatter.PrintToken(Tokens.ReadOnly);
-					outputFormatter.Space();
-				} else if (propertyDeclaration.IsWriteOnly) {
-					outputFormatter.PrintToken(Tokens.WriteOnly);
-					outputFormatter.Space();
-				}
-			}
-			
-			outputFormatter.PrintToken(Tokens.Property);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(propertyDeclaration.Name);
-			
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(propertyDeclaration.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			if (!propertyDeclaration.TypeReference.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				
-				VisitReturnTypeAttributes(propertyDeclaration.Attributes, data);
-				
-				ObjectCreateExpression init = propertyDeclaration.Initializer as ObjectCreateExpression;
-				if (init != null && TypeReference.AreEqualReferences(init.CreateType, propertyDeclaration.TypeReference)) {
-					TrackedVisit(propertyDeclaration.Initializer, data);
-				} else {
-					TrackedVisit(propertyDeclaration.TypeReference, data);
-				}
-			}
-			
-			PrintInterfaceImplementations(propertyDeclaration.InterfaceImplementations);
-			
-			if (!propertyDeclaration.Initializer.IsNull && !(propertyDeclaration.Initializer is ObjectCreateExpression)) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Assign);
-				outputFormatter.Space();
-				TrackedVisit(propertyDeclaration.Initializer, data);
-			}
-			
-			outputFormatter.NewLine();
-			
-			if (!IsAbstract(propertyDeclaration) && (propertyDeclaration.GetRegion.Block != NullBlockStatement.Instance  || propertyDeclaration.SetRegion.Block != NullBlockStatement.Instance)) {
-				outputFormatter.IsInMemberBody = true;
-				++outputFormatter.IndentationLevel;
-				exitTokenStack.Push(Tokens.Property);
-				TrackedVisit(propertyDeclaration.GetRegion, data);
-				TrackedVisit(propertyDeclaration.SetRegion, data);
-				exitTokenStack.Pop();
-				--outputFormatter.IndentationLevel;
-				outputFormatter.IsInMemberBody = false;
-				
-				outputFormatter.Indent();
-				outputFormatter.PrintToken(Tokens.End);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Property);
-				outputFormatter.NewLine();
-			}
-			
-			return null;
-		}
-		
-		public override object TrackedVisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data)
-		{
-			VisitAttributes(propertyGetRegion.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(propertyGetRegion.Modifier);
-			outputFormatter.PrintToken(Tokens.Get);
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			TrackedVisit(propertyGetRegion.Block, data);
-			--outputFormatter.IndentationLevel;
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Get);
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitPropertySetRegion(PropertySetRegion propertySetRegion, object data)
-		{
-			VisitAttributes(propertySetRegion.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(propertySetRegion.Modifier);
-			outputFormatter.PrintToken(Tokens.Set);
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			TrackedVisit(propertySetRegion.Block, data);
-			--outputFormatter.IndentationLevel;
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Set);
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		TypeReference currentEventType = null;
-		public override object TrackedVisitEventDeclaration(EventDeclaration eventDeclaration, object data)
-		{
-			bool customEvent = eventDeclaration.HasAddRegion  || eventDeclaration.HasRemoveRegion;
-			
-			VisitAttributes(eventDeclaration.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(eventDeclaration.Modifier);
-			if (customEvent) {
-				outputFormatter.PrintText("Custom");
-				outputFormatter.Space();
-			}
-			
-			outputFormatter.PrintToken(Tokens.Event);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(eventDeclaration.Name);
-			
-			if (eventDeclaration.Parameters.Count > 0) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				this.AppendCommaSeparatedList(eventDeclaration.Parameters);
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-			if (!eventDeclaration.TypeReference.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				VisitReturnTypeAttributes(eventDeclaration.Attributes, data);
-				TrackedVisit(eventDeclaration.TypeReference, data);
-			}
-			
-			PrintInterfaceImplementations(eventDeclaration.InterfaceImplementations);
-			
-			if (!eventDeclaration.Initializer.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Assign);
-				outputFormatter.Space();
-				TrackedVisit(eventDeclaration.Initializer, data);
-			}
-			
-			outputFormatter.NewLine();
-			
-			if (customEvent) {
-				++outputFormatter.IndentationLevel;
-				currentEventType = eventDeclaration.TypeReference;
-				exitTokenStack.Push(Tokens.Sub);
-				TrackedVisit(eventDeclaration.AddRegion, data);
-				TrackedVisit(eventDeclaration.RemoveRegion, data);
-				exitTokenStack.Pop();
-				--outputFormatter.IndentationLevel;
-				
-				outputFormatter.Indent();
-				outputFormatter.PrintToken(Tokens.End);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Event);
-				outputFormatter.NewLine();
-			}
-			return null;
-		}
-		
-		void PrintInterfaceImplementations(IList<InterfaceImplementation> list)
-		{
-			if (list == null || list.Count == 0)
-				return;
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Implements);
-			for (int i = 0; i < list.Count; i++) {
-				if (i > 0)
-					outputFormatter.PrintToken(Tokens.Comma);
-				outputFormatter.Space();
-				TrackedVisit(list[i].InterfaceType, null);
-				outputFormatter.PrintToken(Tokens.Dot);
-				outputFormatter.PrintIdentifier(list[i].MemberName);
-			}
-		}
-		
-		public override object TrackedVisitEventAddRegion(EventAddRegion eventAddRegion, object data)
-		{
-			VisitAttributes(eventAddRegion.Attributes, data);
-			outputFormatter.Indent();
-			outputFormatter.PrintText("AddHandler(");
-			if (eventAddRegion.Parameters.Count == 0) {
-				outputFormatter.PrintToken(Tokens.ByVal);
-				outputFormatter.Space();
-				outputFormatter.PrintIdentifier("value");
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				TrackedVisit(currentEventType, data);
-			} else {
-				this.AppendCommaSeparatedList(eventAddRegion.Parameters);
-			}
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			TrackedVisit(eventAddRegion.Block, data);
-			--outputFormatter.IndentationLevel;
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintText("AddHandler");
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data)
-		{
-			VisitAttributes(eventRemoveRegion.Attributes, data);
-			outputFormatter.Indent();
-			outputFormatter.PrintText("RemoveHandler");
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			if (eventRemoveRegion.Parameters.Count == 0) {
-				outputFormatter.PrintToken(Tokens.ByVal);
-				outputFormatter.Space();
-				outputFormatter.PrintIdentifier("value");
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				TrackedVisit(currentEventType, data);
-			} else {
-				this.AppendCommaSeparatedList(eventRemoveRegion.Parameters);
-			}
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			TrackedVisit(eventRemoveRegion.Block, data);
-			--outputFormatter.IndentationLevel;
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintText("RemoveHandler");
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data)
-		{
-			VisitAttributes(eventRaiseRegion.Attributes, data);
-			outputFormatter.Indent();
-			outputFormatter.PrintText("RaiseEvent");
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			if (eventRaiseRegion.Parameters.Count == 0) {
-				outputFormatter.PrintToken(Tokens.ByVal);
-				outputFormatter.Space();
-				outputFormatter.PrintIdentifier("value");
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				TrackedVisit(currentEventType, data);
-			} else {
-				this.AppendCommaSeparatedList(eventRaiseRegion.Parameters);
-			}
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			TrackedVisit(eventRaiseRegion.Block, data);
-			--outputFormatter.IndentationLevel;
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintText("RaiseEvent");
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)
-		{
-			printAttributeSectionInline = true;
-			VisitAttributes(parameterDeclarationExpression.Attributes, data);
-			printAttributeSectionInline = false;
-			OutputModifier(parameterDeclarationExpression.ParamModifier);
-			outputFormatter.PrintIdentifier(parameterDeclarationExpression.ParameterName);
-			if (!parameterDeclarationExpression.TypeReference.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				VisitReturnTypeAttributes(parameterDeclarationExpression.Attributes, data);
-				TrackedVisit(parameterDeclarationExpression.TypeReference, data);
-			}
-			if (!parameterDeclarationExpression.DefaultValue.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Assign);
-				outputFormatter.Space();
-				TrackedVisit(parameterDeclarationExpression.DefaultValue, data);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
-		{
-			VisitAttributes(methodDeclaration.Attributes, data);
-			if (methodDeclaration.IsExtensionMethod) {
-				outputFormatter.Indent();
-				outputFormatter.PrintText("<System.Runtime.CompilerServices.Extension> _");
-				outputFormatter.NewLine();
-			}
-			outputFormatter.Indent();
-			OutputModifier(methodDeclaration.Modifier);
-			
-			bool isSub = methodDeclaration.TypeReference.IsNull ||
-				methodDeclaration.TypeReference.Type == "System.Void";
-			
-			if (isSub) {
-				outputFormatter.PrintToken(Tokens.Sub);
-			} else {
-				outputFormatter.PrintToken(Tokens.Function);
-			}
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(methodDeclaration.Name);
-			
-			PrintTemplates(methodDeclaration.Templates);
-			
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(methodDeclaration.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			if (!isSub) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				VisitReturnTypeAttributes(methodDeclaration.Attributes, data);
-				TrackedVisit(methodDeclaration.TypeReference, data);
-			}
-			
-			PrintInterfaceImplementations(methodDeclaration.InterfaceImplementations);
-			
-			if (methodDeclaration.HandlesClause.Count > 0) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Handles);
-				for (int i = 0; i < methodDeclaration.HandlesClause.Count; i++) {
-					if (i > 0)
-						outputFormatter.PrintToken(Tokens.Comma);
-					outputFormatter.Space();
-					outputFormatter.PrintText(methodDeclaration.HandlesClause[i]);
-				}
-			}
-			
-			outputFormatter.NewLine();
-			
-			if (!IsAbstract(methodDeclaration)) {
-				outputFormatter.IsInMemberBody = true;
-				BeginVisit(methodDeclaration.Body);
-				++outputFormatter.IndentationLevel;
-				exitTokenStack.Push(isSub ? Tokens.Sub : Tokens.Function);
-				// we're doing the tracking manually using BeginVisit/EndVisit, so call Tracked... directly
-				this.TrackedVisitBlockStatement(methodDeclaration.Body, data);
-				exitTokenStack.Pop();
-				--outputFormatter.IndentationLevel;
-				
-				outputFormatter.Indent();
-				outputFormatter.PrintToken(Tokens.End);
-				outputFormatter.Space();
-				if (isSub) {
-					outputFormatter.PrintToken(Tokens.Sub);
-				} else {
-					outputFormatter.PrintToken(Tokens.Function);
-				}
-				outputFormatter.NewLine();
-				EndVisit(methodDeclaration.Body);
-				outputFormatter.IsInMemberBody = false;
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data)
-		{
-			throw new InvalidOperationException();
-		}
-		
-		bool IsAbstract(AttributedNode node)
-		{
-			if ((node.Modifier & Modifiers.Abstract) == Modifiers.Abstract)
-				return true;
-			return currentType != null && currentType.Type == ClassType.Interface;
-		}
-		
-		public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
-		{
-			VisitAttributes(constructorDeclaration.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(constructorDeclaration.Modifier);
-			outputFormatter.PrintToken(Tokens.Sub);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.New);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(constructorDeclaration.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			outputFormatter.NewLine();
-			
-			outputFormatter.IsInMemberBody = true;
-			++outputFormatter.IndentationLevel;
-			exitTokenStack.Push(Tokens.Sub);
-			
-			TrackedVisit(constructorDeclaration.ConstructorInitializer, data);
-			
-			TrackedVisit(constructorDeclaration.Body, data);
-			exitTokenStack.Pop();
-			--outputFormatter.IndentationLevel;
-			outputFormatter.IsInMemberBody = false;
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Sub);
-			outputFormatter.NewLine();
-			
-			return null;
-		}
-		
-		public override object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
-		{
-			outputFormatter.Indent();
-			if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This) {
-				outputFormatter.PrintToken(Tokens.Me);
-			} else {
-				outputFormatter.PrintToken(Tokens.MyBase);
-			}
-			outputFormatter.PrintToken(Tokens.Dot);
-			outputFormatter.PrintToken(Tokens.New);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(constructorInitializer.Arguments);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			outputFormatter.NewLine();
-			return null;
-		}
-		
-		public override object TrackedVisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)
-		{
-			VisitAttributes(operatorDeclaration.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(operatorDeclaration.Modifier);
-			
-			if (operatorDeclaration.IsConversionOperator) {
-				if (operatorDeclaration.ConversionType == ConversionType.Implicit) {
-					outputFormatter.PrintToken(Tokens.Widening);
-				} else {
-					outputFormatter.PrintToken(Tokens.Narrowing);
-				}
-				outputFormatter.Space();
-			}
-			
-			outputFormatter.PrintToken(Tokens.Operator);
-			outputFormatter.Space();
-			
-			int op = -1;
-			
-			switch(operatorDeclaration.OverloadableOperator)
-			{
-				case OverloadableOperatorType.Add:
-				case OverloadableOperatorType.UnaryPlus:
-					op = Tokens.Plus;
-					break;
-				case OverloadableOperatorType.UnaryMinus:
-				case OverloadableOperatorType.Subtract:
-					op = Tokens.Minus;
-					break;
-				case OverloadableOperatorType.Multiply:
-					op = Tokens.Times;
-					break;
-				case OverloadableOperatorType.Divide:
-					op = Tokens.Div;
-					break;
-				case OverloadableOperatorType.Modulus:
-					op = Tokens.Mod;
-					break;
-				case OverloadableOperatorType.Concat:
-					op = Tokens.ConcatString;
-					break;
-				case OverloadableOperatorType.Not:
-					op = Tokens.Not;
-					break;
-				case OverloadableOperatorType.BitNot:
-					op = Tokens.Not;
-					break;
-				case OverloadableOperatorType.BitwiseAnd:
-					op = Tokens.And;
-					break;
-				case OverloadableOperatorType.BitwiseOr:
-					op = Tokens.Or;
-					break;
-				case OverloadableOperatorType.ExclusiveOr:
-					op = Tokens.Xor;
-					break;
-				case OverloadableOperatorType.ShiftLeft:
-					op = Tokens.ShiftLeft;
-					break;
-				case OverloadableOperatorType.ShiftRight:
-					op = Tokens.ShiftRight;
-					break;
-				case OverloadableOperatorType.GreaterThan:
-					op = Tokens.GreaterThan;
-					break;
-				case OverloadableOperatorType.GreaterThanOrEqual:
-					op = Tokens.GreaterEqual;
-					break;
-				case OverloadableOperatorType.Equality:
-					op = Tokens.Assign;
-					break;
-				case OverloadableOperatorType.InEquality:
-					op = Tokens.NotEqual;
-					break;
-				case OverloadableOperatorType.LessThan:
-					op = Tokens.LessThan;
-					break;
-				case OverloadableOperatorType.LessThanOrEqual:
-					op = Tokens.LessEqual;
-					break;
-				case OverloadableOperatorType.Increment:
-					Error("Increment operator is not supported in Visual Basic", operatorDeclaration.StartLocation);
-					break;
-				case OverloadableOperatorType.Decrement:
-					Error("Decrement operator is not supported in Visual Basic", operatorDeclaration.StartLocation);
-					break;
-				case OverloadableOperatorType.IsTrue:
-					outputFormatter.PrintText("IsTrue");
-					break;
-				case OverloadableOperatorType.IsFalse:
-					outputFormatter.PrintText("IsFalse");
-					break;
-				case OverloadableOperatorType.Like:
-					op = Tokens.Like;
-					break;
-				case OverloadableOperatorType.Power:
-					op = Tokens.Power;
-					break;
-				case OverloadableOperatorType.CType:
-					op = Tokens.CType;
-					break;
-				case OverloadableOperatorType.DivideInteger:
-					op = Tokens.DivInteger;
-					break;
-			}
-			
-			
-			
-			if (operatorDeclaration.IsConversionOperator) {
-				outputFormatter.PrintToken(Tokens.CType);
-			} else {
-				if(op != -1)  outputFormatter.PrintToken(op);
-			}
-			
-			PrintTemplates(operatorDeclaration.Templates);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(operatorDeclaration.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			if (!operatorDeclaration.TypeReference.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				VisitReturnTypeAttributes(operatorDeclaration.Attributes, data);
-				TrackedVisit(operatorDeclaration.TypeReference, data);
-			}
-			
-			outputFormatter.NewLine();
-			
-			++outputFormatter.IndentationLevel;
-			TrackedVisit(operatorDeclaration.Body, data);
-			--outputFormatter.IndentationLevel;
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Operator);
-			outputFormatter.NewLine();
-			
-			return null;
-		}
-		
-		public override object TrackedVisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)
-		{
-			VisitAttributes(declareDeclaration.Attributes, data);
-			outputFormatter.Indent();
-			OutputModifier(declareDeclaration.Modifier);
-			outputFormatter.PrintToken(Tokens.Declare);
-			outputFormatter.Space();
-			
-			switch (declareDeclaration.Charset) {
-				case CharsetModifier.Auto:
-					outputFormatter.PrintToken(Tokens.Auto);
-					outputFormatter.Space();
-					break;
-				case CharsetModifier.Unicode:
-					outputFormatter.PrintToken(Tokens.Unicode);
-					outputFormatter.Space();
-					break;
-				case CharsetModifier.Ansi:
-					outputFormatter.PrintToken(Tokens.Ansi);
-					outputFormatter.Space();
-					break;
-			}
-			
-			bool isVoid = declareDeclaration.TypeReference.IsNull || declareDeclaration.TypeReference.Type == "System.Void";
-			if (isVoid) {
-				outputFormatter.PrintToken(Tokens.Sub);
-			} else {
-				outputFormatter.PrintToken(Tokens.Function);
-			}
-			outputFormatter.Space();
-			
-			outputFormatter.PrintIdentifier(declareDeclaration.Name);
-			
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Lib);
-			outputFormatter.Space();
-			outputFormatter.PrintText(ConvertString(declareDeclaration.Library));
-			outputFormatter.Space();
-			
-			if (declareDeclaration.Alias.Length > 0) {
-				outputFormatter.PrintToken(Tokens.Alias);
-				outputFormatter.Space();
-				outputFormatter.PrintText(ConvertString(declareDeclaration.Alias));
-				outputFormatter.Space();
-			}
-			
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(declareDeclaration.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			if (!isVoid) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				VisitReturnTypeAttributes(declareDeclaration.Attributes, data);
-				TrackedVisit(declareDeclaration.TypeReference, data);
-			}
-			
-			outputFormatter.NewLine();
-			
-			return null;
-		}
-		#endregion
-		
-		#region Statements
-		public override object TrackedVisitBlockStatement(BlockStatement blockStatement, object data)
-		{
-			if (blockStatement.Parent is BlockStatement) {
-				outputFormatter.Indent();
-				outputFormatter.PrintText("If True Then");
-				outputFormatter.NewLine();
-				outputFormatter.IndentationLevel += 1;
-			}
-			VisitStatementList(blockStatement.Children);
-			if (blockStatement.Parent is BlockStatement) {
-				outputFormatter.IndentationLevel -= 1;
-				outputFormatter.Indent();
-				outputFormatter.PrintText("End If");
-				outputFormatter.NewLine();
-			}
-			return null;
-		}
-		
-		void PrintIndentedBlock(Statement stmt)
-		{
-			outputFormatter.IndentationLevel += 1;
-			if (stmt is BlockStatement) {
-				TrackedVisit(stmt, null);
-			} else {
-				outputFormatter.Indent();
-				TrackedVisit(stmt, null);
-				outputFormatter.NewLine();
-			}
-			outputFormatter.IndentationLevel -= 1;
-		}
-		
-		void PrintIndentedBlock(IEnumerable statements)
-		{
-			outputFormatter.IndentationLevel += 1;
-			VisitStatementList(statements);
-			outputFormatter.IndentationLevel -= 1;
-		}
-		
-		void VisitStatementList(IEnumerable statements)
-		{
-			foreach (Statement stmt in statements) {
-				if (stmt is BlockStatement) {
-					TrackedVisit(stmt, null);
-				} else {
-					outputFormatter.Indent();
-					TrackedVisit(stmt, null);
-					outputFormatter.NewLine();
-				}
-			}
-		}
-		
-		public override object TrackedVisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.AddHandler);
-			outputFormatter.Space();
-			TrackedVisit(addHandlerStatement.EventExpression, data);
-			outputFormatter.PrintToken(Tokens.Comma);
-			outputFormatter.Space();
-			TrackedVisit(addHandlerStatement.HandlerExpression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.RemoveHandler);
-			outputFormatter.Space();
-			TrackedVisit(removeHandlerStatement.EventExpression, data);
-			outputFormatter.PrintToken(Tokens.Comma);
-			outputFormatter.Space();
-			TrackedVisit(removeHandlerStatement.HandlerExpression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.RaiseEvent);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(raiseEventStatement.EventName);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(raiseEventStatement.Arguments);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		public override object TrackedVisitEraseStatement(EraseStatement eraseStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Erase);
-			outputFormatter.Space();
-			AppendCommaSeparatedList(eraseStatement.Expressions);
-			return null;
-		}
-		
-		public override object TrackedVisitErrorStatement(ErrorStatement errorStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Error);
-			outputFormatter.Space();
-			TrackedVisit(errorStatement.Expression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitOnErrorStatement(OnErrorStatement onErrorStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.On);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Error);
-			outputFormatter.Space();
-			TrackedVisit(onErrorStatement.EmbeddedStatement, data);
-			return null;
-		}
-		
-		public override object TrackedVisitReDimStatement(ReDimStatement reDimStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.ReDim);
-			outputFormatter.Space();
-			if (reDimStatement.IsPreserve) {
-				outputFormatter.PrintToken(Tokens.Preserve);
-				outputFormatter.Space();
-			}
-			
-			AppendCommaSeparatedList(reDimStatement.ReDimClauses);
-			return null;
-		}
-		
-		public override object TrackedVisitExpressionStatement(ExpressionStatement expressionStatement, object data)
-		{
-			TrackedVisit(expressionStatement.Expression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
-		{
-			if (localVariableDeclaration.Modifier != Modifiers.None) {
-				OutputModifier(localVariableDeclaration.Modifier & ~Modifiers.Dim);
-			}
-			if (!isUsingResourceAcquisition) {
-				if ((localVariableDeclaration.Modifier & Modifiers.Const) == 0) {
-					outputFormatter.PrintToken(Tokens.Dim);
-				}
-				outputFormatter.Space();
-			}
-			currentVariableType = localVariableDeclaration.TypeReference;
-			
-			AppendCommaSeparatedList(localVariableDeclaration.Variables);
-			currentVariableType = null;
-			
-			return null;
-		}
-		
-		public override object TrackedVisitReturnStatement(ReturnStatement returnStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Return);
-			if (!returnStatement.Expression.IsNull) {
-				outputFormatter.Space();
-				TrackedVisit(returnStatement.Expression, data);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitIfElseStatement(IfElseStatement ifElseStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.If);
-			outputFormatter.Space();
-			TrackedVisit(ifElseStatement.Condition, data);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Then);
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(ifElseStatement.TrueStatement);
-			
-			foreach (ElseIfSection elseIfSection in ifElseStatement.ElseIfSections) {
-				TrackedVisit(elseIfSection, data);
-			}
-			
-			if (ifElseStatement.HasElseStatements) {
-				outputFormatter.Indent();
-				outputFormatter.PrintToken(Tokens.Else);
-				outputFormatter.NewLine();
-				PrintIndentedBlock(ifElseStatement.FalseStatement);
-			}
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.If);
-			return null;
-		}
-		
-		public override object TrackedVisitElseIfSection(ElseIfSection elseIfSection, object data)
-		{
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.ElseIf);
-			outputFormatter.Space();
-			TrackedVisit(elseIfSection.Condition, data);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Then);
-			outputFormatter.NewLine();
-			PrintIndentedBlock(elseIfSection.EmbeddedStatement);
-			return null;
-		}
-		
-		public override object TrackedVisitLabelStatement(LabelStatement labelStatement, object data)
-		{
-			outputFormatter.PrintIdentifier(labelStatement.Label);
-			outputFormatter.PrintToken(Tokens.Colon);
-			return null;
-		}
-		
-		public override object TrackedVisitGotoStatement(GotoStatement gotoStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.GoTo);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(gotoStatement.Label);
-			return null;
-		}
-		
-		public override object TrackedVisitSwitchStatement(SwitchStatement switchStatement, object data)
-		{
-			exitTokenStack.Push(Tokens.Select);
-			outputFormatter.PrintToken(Tokens.Select);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Case);
-			outputFormatter.Space();
-			TrackedVisit(switchStatement.SwitchExpression, data);
-			outputFormatter.NewLine();
-			++outputFormatter.IndentationLevel;
-			foreach (SwitchSection section in switchStatement.SwitchSections) {
-				TrackedVisit(section, data);
-			}
-			--outputFormatter.IndentationLevel;
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Select);
-			exitTokenStack.Pop();
-			return null;
-		}
-		
-		public override object TrackedVisitSwitchSection(SwitchSection switchSection, object data)
-		{
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.Case);
-			outputFormatter.Space();
-			this.AppendCommaSeparatedList(switchSection.SwitchLabels);
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(switchSection.Children);
-			
-			return null;
-		}
-		
-		public override object TrackedVisitCaseLabel(CaseLabel caseLabel, object data)
-		{
-			if (caseLabel.IsDefault) {
-				outputFormatter.PrintToken(Tokens.Else);
-			} else {
-				if (caseLabel.BinaryOperatorType != BinaryOperatorType.None) {
-					switch (caseLabel.BinaryOperatorType) {
-						case BinaryOperatorType.Equality:
-							outputFormatter.PrintToken(Tokens.Assign);
-							break;
-						case BinaryOperatorType.InEquality:
-							outputFormatter.PrintToken(Tokens.LessThan);
-							outputFormatter.PrintToken(Tokens.GreaterThan);
-							break;
-							
-						case BinaryOperatorType.GreaterThan:
-							outputFormatter.PrintToken(Tokens.GreaterThan);
-							break;
-						case BinaryOperatorType.GreaterThanOrEqual:
-							outputFormatter.PrintToken(Tokens.GreaterEqual);
-							break;
-						case BinaryOperatorType.LessThan:
-							outputFormatter.PrintToken(Tokens.LessThan);
-							break;
-						case BinaryOperatorType.LessThanOrEqual:
-							outputFormatter.PrintToken(Tokens.LessEqual);
-							break;
-					}
-					outputFormatter.Space();
-				}
-				
-				TrackedVisit(caseLabel.Label, data);
-				if (!caseLabel.ToExpression.IsNull) {
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.To);
-					outputFormatter.Space();
-					TrackedVisit(caseLabel.ToExpression, data);
-				}
-			}
-			
-			return null;
-		}
-		
-		public override object TrackedVisitStopStatement(StopStatement stopStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Stop);
-			return null;
-		}
-		
-		public override object TrackedVisitResumeStatement(ResumeStatement resumeStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Resume);
-			outputFormatter.Space();
-			if (resumeStatement.IsResumeNext) {
-				outputFormatter.PrintToken(Tokens.Next);
-			} else {
-				outputFormatter.PrintIdentifier(resumeStatement.LabelName);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitEndStatement(EndStatement endStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.End);
-			return null;
-		}
-		
-		public override object TrackedVisitContinueStatement(ContinueStatement continueStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Continue);
-			outputFormatter.Space();
-			switch (continueStatement.ContinueType) {
-				case ContinueType.Do:
-					outputFormatter.PrintToken(Tokens.Do);
-					break;
-				case ContinueType.For:
-					outputFormatter.PrintToken(Tokens.For);
-					break;
-				case ContinueType.While:
-					outputFormatter.PrintToken(Tokens.While);
-					break;
-				default:
-					outputFormatter.PrintToken(exitTokenStack.Peek());
-					break;
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitDoLoopStatement(DoLoopStatement doLoopStatement, object data)
-		{
-			if (doLoopStatement.ConditionPosition == ConditionPosition.None) {
-				Error(String.Format("Unknown condition position for loop : {0}.", doLoopStatement), doLoopStatement.StartLocation);
-			}
-			
-			if (doLoopStatement.ConditionPosition == ConditionPosition.Start) {
-				switch (doLoopStatement.ConditionType) {
-					case ConditionType.DoWhile:
-						exitTokenStack.Push(Tokens.Do);
-						outputFormatter.PrintToken(Tokens.Do);
-						outputFormatter.Space();
-						outputFormatter.PrintToken(Tokens.While);
-						break;
-					case ConditionType.While:
-						exitTokenStack.Push(Tokens.While);
-						outputFormatter.PrintToken(Tokens.While);
-						break;
-					case ConditionType.Until:
-						exitTokenStack.Push(Tokens.Do);
-						outputFormatter.PrintToken(Tokens.Do);
-						outputFormatter.Space();
-						outputFormatter.PrintToken(Tokens.While);
-						break;
-					default:
-						throw new InvalidOperationException();
-				}
-				outputFormatter.Space();
-				TrackedVisit(doLoopStatement.Condition, null);
-			} else {
-				exitTokenStack.Push(Tokens.Do);
-				outputFormatter.PrintToken(Tokens.Do);
-			}
-			
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(doLoopStatement.EmbeddedStatement);
-			
-			outputFormatter.Indent();
-			if (doLoopStatement.ConditionPosition == ConditionPosition.Start && doLoopStatement.ConditionType == ConditionType.While) {
-				outputFormatter.PrintToken(Tokens.End);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.While);
-			} else {
-				outputFormatter.PrintToken(Tokens.Loop);
-			}
-			
-			if (doLoopStatement.ConditionPosition == ConditionPosition.End && !doLoopStatement.Condition.IsNull) {
-				outputFormatter.Space();
-				switch (doLoopStatement.ConditionType) {
-					case ConditionType.While:
-					case ConditionType.DoWhile:
-						outputFormatter.PrintToken(Tokens.While);
-						break;
-					case ConditionType.Until:
-						outputFormatter.PrintToken(Tokens.Until);
-						break;
-				}
-				outputFormatter.Space();
-				TrackedVisit(doLoopStatement.Condition, null);
-			}
-			exitTokenStack.Pop();
-			return null;
-		}
-		
-		public override object TrackedVisitForeachStatement(ForeachStatement foreachStatement, object data)
-		{
-			exitTokenStack.Push(Tokens.For);
-			outputFormatter.PrintToken(Tokens.For);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Each);
-			outputFormatter.Space();
-			
-			// loop control variable
-			outputFormatter.PrintIdentifier(foreachStatement.VariableName);
-			if (!foreachStatement.TypeReference.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				TrackedVisit(foreachStatement.TypeReference, data);
-			}
-			
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.In);
-			outputFormatter.Space();
-			
-			TrackedVisit(foreachStatement.Expression, data);
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(foreachStatement.EmbeddedStatement);
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.Next);
-			if (!foreachStatement.NextExpression.IsNull) {
-				outputFormatter.Space();
-				TrackedVisit(foreachStatement.NextExpression, data);
-			}
-			exitTokenStack.Pop();
-			return null;
-		}
-		
-		public override object TrackedVisitLockStatement(LockStatement lockStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.SyncLock);
-			outputFormatter.Space();
-			TrackedVisit(lockStatement.LockExpression, data);
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(lockStatement.EmbeddedStatement);
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.SyncLock);
-			return null;
-		}
-		
-		bool isUsingResourceAcquisition;
-		
-		public override object TrackedVisitUsingStatement(UsingStatement usingStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Using);
-			outputFormatter.Space();
-			
-			isUsingResourceAcquisition = true;
-			TrackedVisit(usingStatement.ResourceAcquisition, data);
-			isUsingResourceAcquisition = false;
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(usingStatement.EmbeddedStatement);
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Using);
-			
-			return null;
-		}
-		
-		public override object TrackedVisitWithStatement(WithStatement withStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.With);
-			outputFormatter.Space();
-			TrackedVisit(withStatement.Expression, data);
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(withStatement.Body);
-			
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.With);
-			return null;
-		}
-		
-		public override object TrackedVisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
-		{
-			exitTokenStack.Push(Tokens.Try);
-			outputFormatter.PrintToken(Tokens.Try);
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(tryCatchStatement.StatementBlock);
-			
-			foreach (CatchClause catchClause in tryCatchStatement.CatchClauses) {
-				TrackedVisit(catchClause, data);
-			}
-			
-			if (!tryCatchStatement.FinallyBlock.IsNull) {
-				outputFormatter.Indent();
-				outputFormatter.PrintToken(Tokens.Finally);
-				outputFormatter.NewLine();
-				PrintIndentedBlock(tryCatchStatement.FinallyBlock);
-			}
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.End);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Try);
-			exitTokenStack.Pop();
-			return null;
-		}
-		
-		public override object TrackedVisitCatchClause(CatchClause catchClause, object data)
-		{
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.Catch);
-			
-			if (!catchClause.TypeReference.IsNull) {
-				outputFormatter.Space();
-				if (catchClause.VariableName.Length > 0) {
-					outputFormatter.PrintIdentifier(catchClause.VariableName);
-				} else {
-					outputFormatter.PrintIdentifier("generatedExceptionName");
-				}
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.As);
-				outputFormatter.Space();
-				outputFormatter.PrintIdentifier(catchClause.TypeReference.Type);
-			}
-			
-			if (!catchClause.Condition.IsNull)  {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.When);
-				outputFormatter.Space();
-				TrackedVisit(catchClause.Condition, data);
-			}
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(catchClause.StatementBlock);
-			
-			return null;
-		}
-		
-		public override object TrackedVisitThrowStatement(ThrowStatement throwStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Throw);
-			if (!throwStatement.Expression.IsNull) {
-				outputFormatter.Space();
-				TrackedVisit(throwStatement.Expression, data);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitExitStatement(ExitStatement exitStatement, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Exit);
-			if (exitStatement.ExitType != ExitType.None) {
-				outputFormatter.Space();
-				switch (exitStatement.ExitType) {
-					case ExitType.Sub:
-						outputFormatter.PrintToken(Tokens.Sub);
-						break;
-					case ExitType.Function:
-						outputFormatter.PrintToken(Tokens.Function);
-						break;
-					case ExitType.Property:
-						outputFormatter.PrintToken(Tokens.Property);
-						break;
-					case ExitType.Do:
-						outputFormatter.PrintToken(Tokens.Do);
-						break;
-					case ExitType.For:
-						outputFormatter.PrintToken(Tokens.For);
-						break;
-					case ExitType.Try:
-						outputFormatter.PrintToken(Tokens.Try);
-						break;
-					case ExitType.While:
-						outputFormatter.PrintToken(Tokens.While);
-						break;
-					case ExitType.Select:
-						outputFormatter.PrintToken(Tokens.Select);
-						break;
-					default:
-						Error(String.Format("Unsupported exit type : {0}", exitStatement.ExitType), exitStatement.StartLocation);
-						break;
-				}
-			}
-			
-			return null;
-		}
-		
-		public override object TrackedVisitForNextStatement(ForNextStatement forNextStatement, object data)
-		{
-			exitTokenStack.Push(Tokens.For);
-			outputFormatter.PrintToken(Tokens.For);
-			outputFormatter.Space();
-			
-			if (!forNextStatement.LoopVariableExpression.IsNull) {
-				TrackedVisit(forNextStatement.LoopVariableExpression, data);
-			} else {
-				outputFormatter.PrintIdentifier(forNextStatement.VariableName);
-				
-				if (!forNextStatement.TypeReference.IsNull) {
-					outputFormatter.Space();
-					outputFormatter.PrintToken(Tokens.As);
-					outputFormatter.Space();
-					TrackedVisit(forNextStatement.TypeReference, data);
-				}
-			}
-			
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Assign);
-			outputFormatter.Space();
-			
-			TrackedVisit(forNextStatement.Start, data);
-			
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.To);
-			outputFormatter.Space();
-			
-			TrackedVisit(forNextStatement.End, data);
-			
-			if (!forNextStatement.Step.IsNull) {
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Step);
-				outputFormatter.Space();
-				TrackedVisit(forNextStatement.Step, data);
-			}
-			outputFormatter.NewLine();
-			
-			PrintIndentedBlock(forNextStatement.EmbeddedStatement);
-			
-			outputFormatter.Indent();
-			outputFormatter.PrintToken(Tokens.Next);
-			
-			if (forNextStatement.NextExpressions.Count > 0) {
-				outputFormatter.Space();
-				AppendCommaSeparatedList(forNextStatement.NextExpressions);
-			}
-			exitTokenStack.Pop();
-			return null;
-		}
-		#endregion
-		
-		#region Expressions
-		
-		public override object TrackedVisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.MyClass);
-			return null;
-		}
-		
-		
-		static string ConvertCharLiteral(char ch)
-		{
-			if (Char.IsControl(ch)) {
-				string charName = GetCharName(ch);
-				if (charName != null)
-					return "ControlChars." + charName;
-				else
-					return "ChrW(" + ((int)ch).ToString() + ")";
-			} else if (ch == '"') {
-				return "\"\"\"\"C";
-			} else {
-				return "\"" + ch.ToString() + "\"C";
-			}
-		}
-		
-		static string GetCharName(char ch)
-		{
-			switch (ch) {
-				case '\b':
-					return "Back";
-				case '\r':
-					return "Cr";
-				case '\f':
-					return "FormFeed";
-				case '\n':
-					return "Lf";
-				case '\0':
-					return "NullChar";
-				case '\t':
-					return "Tab";
-				case '\v':
-					return "VerticalTab";
-				default:
-					return null;
-			}
-		}
-		
-		static string ConvertString(string str)
-		{
-			StringBuilder sb = new StringBuilder();
-			bool inString = false;
-			foreach (char ch in str) {
-				if (char.IsControl(ch)) {
-					if (inString) {
-						sb.Append('"');
-						inString = false;
-					}
-					if (sb.Length > 0)
-						sb.Append(" & ");
-					string charName = GetCharName(ch);
-					if (charName != null)
-						sb.Append("vb" + charName);
-					else
-						sb.Append("ChrW(" + ((int)ch) + ")");
-				} else {
-					if (!inString) {
-						if (sb.Length > 0)
-							sb.Append(" & ");
-						sb.Append('"');
-						inString = true;
-					}
-					if (ch == '"') {
-						sb.Append("\"\"");
-					} else {
-						sb.Append(ch);
-					}
-				}
-			}
-			if (inString)
-				sb.Append('"');
-			if (sb.Length == 0)
-				return "\"\"";
-			return sb.ToString();
-		}
-		
-		public override object TrackedVisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
-		{
-			outputFormatter.PrintText(ToVBNetString(primitiveExpression));
-			return null;
-		}
-		
-		internal static string ToVBNetString(PrimitiveExpression primitiveExpression)
-		{
-			object val = primitiveExpression.Value;
-			if (val == null) {
-				return "Nothing";
-			}
-			if (val is bool) {
-				if ((bool)primitiveExpression.Value) {
-					return "True";
-				} else {
-					return "False";
-				}
-			}
-			
-			if (val is string) {
-				return ConvertString((string)val);
-			}
-			
-			if (val is char) {
-				return ConvertCharLiteral((char)primitiveExpression.Value);
-			}
-
-			if (val is decimal) {
-				return ((decimal)primitiveExpression.Value).ToString(NumberFormatInfo.InvariantInfo) + "D";
-			}
-			
-			if (val is float) {
-				return ((float)primitiveExpression.Value).ToString(NumberFormatInfo.InvariantInfo) + "F";
-			}
-			
-			if (val is double) {
-				string text = ((double)val).ToString(NumberFormatInfo.InvariantInfo);
-				if (text.IndexOf('.') < 0 && text.IndexOf('E') < 0)
-					return text + ".0";
-				else
-					return text;
-			}
-			
-			if (val is IFormattable) {
-				StringBuilder b = new StringBuilder();
-				if (primitiveExpression.LiteralFormat == LiteralFormat.HexadecimalNumber) {
-					b.Append("&H");
-					b.Append(((IFormattable)val).ToString("x", NumberFormatInfo.InvariantInfo));
-				} else {
-					b.Append(((IFormattable)val).ToString(null, NumberFormatInfo.InvariantInfo));
-				}
-				if (val is ushort || val is uint || val is ulong) {
-					b.Append('U');
-					if (val is uint)
-						b.Append('I');
-				}
-				if (val is long || val is ulong)
-					b.Append('L');
-				if (val is short || val is ushort)
-					b.Append('S');
-				return b.ToString();
-			} else {
-				return val.ToString();
-			}
-		}
-		
-		public override object TrackedVisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
-		{
-			int  op = 0;
-			switch (binaryOperatorExpression.Op) {
-				case BinaryOperatorType.Concat:
-					op = Tokens.ConcatString;
-					break;
-					
-				case BinaryOperatorType.Add:
-					op = Tokens.Plus;
-					break;
-					
-				case BinaryOperatorType.Subtract:
-					op = Tokens.Minus;
-					break;
-					
-				case BinaryOperatorType.Multiply:
-					op = Tokens.Times;
-					break;
-					
-				case BinaryOperatorType.Divide:
-					op = Tokens.Div;
-					break;
-					
-				case BinaryOperatorType.DivideInteger:
-					op = Tokens.DivInteger;
-					break;
-					
-				case BinaryOperatorType.Modulus:
-					op = Tokens.Mod;
-					break;
-					
-				case BinaryOperatorType.ShiftLeft:
-					op = Tokens.ShiftLeft;
-					break;
-					
-				case BinaryOperatorType.ShiftRight:
-					op = Tokens.ShiftRight;
-					break;
-					
-				case BinaryOperatorType.BitwiseAnd:
-					op = Tokens.And;
-					break;
-				case BinaryOperatorType.BitwiseOr:
-					op = Tokens.Or;
-					break;
-				case BinaryOperatorType.ExclusiveOr:
-					op = Tokens.Xor;
-					break;
-					
-				case BinaryOperatorType.LogicalAnd:
-					op = Tokens.AndAlso;
-					break;
-				case BinaryOperatorType.LogicalOr:
-					op = Tokens.OrElse;
-					break;
-				case BinaryOperatorType.ReferenceEquality:
-					op = Tokens.Is;
-					break;
-				case BinaryOperatorType.ReferenceInequality:
-					op = Tokens.IsNot;
-					break;
-					
-				case BinaryOperatorType.Equality:
-					op = Tokens.Assign;
-					break;
-				case BinaryOperatorType.GreaterThan:
-					op = Tokens.GreaterThan;
-					break;
-				case BinaryOperatorType.GreaterThanOrEqual:
-					op = Tokens.GreaterEqual;
-					break;
-				case BinaryOperatorType.InEquality:
-					op = Tokens.NotEqual;
-					break;
-				case BinaryOperatorType.NullCoalescing:
-					outputFormatter.PrintText("If(");
-					TrackedVisit(binaryOperatorExpression.Left, data);
-					outputFormatter.PrintToken(Tokens.Comma);
-					outputFormatter.Space();
-					TrackedVisit(binaryOperatorExpression.Right, data);
-					outputFormatter.PrintToken(Tokens.CloseParenthesis);
-					return null;
-				case BinaryOperatorType.DictionaryAccess:
-					{
-						PrimitiveExpression pright = binaryOperatorExpression.Right as PrimitiveExpression;
-						TrackedVisit(binaryOperatorExpression.Left, data);
-						if (pright != null && pright.Value is string) {
-							outputFormatter.PrintText("!" + (string)pright.Value);
-						} else {
-							outputFormatter.PrintToken(Tokens.OpenParenthesis);
-							TrackedVisit(binaryOperatorExpression.Right, data);
-							outputFormatter.PrintToken(Tokens.CloseParenthesis);
-						}
-						return null;
-					}
-				case BinaryOperatorType.LessThan:
-					op = Tokens.LessThan;
-					break;
-				case BinaryOperatorType.LessThanOrEqual:
-					op = Tokens.LessEqual;
-					break;
-			}
-			
-			
-			BinaryOperatorExpression childBoe = binaryOperatorExpression.Left as BinaryOperatorExpression;
-			bool requireParenthesis = childBoe != null && OperatorPrecedence.ComparePrecedenceVB(binaryOperatorExpression.Op, childBoe.Op) > 0;
-			if (requireParenthesis)
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(binaryOperatorExpression.Left, data);
-			if (requireParenthesis)
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			outputFormatter.Space();
-			outputFormatter.PrintToken(op);
-			outputFormatter.Space();
-			
-			childBoe = binaryOperatorExpression.Right as BinaryOperatorExpression;
-			requireParenthesis = childBoe != null && OperatorPrecedence.ComparePrecedenceVB(binaryOperatorExpression.Op, childBoe.Op) >= 0;
-			if (requireParenthesis)
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(binaryOperatorExpression.Right, data);
-			if (requireParenthesis)
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			return null;
-		}
-		
-		public override object TrackedVisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(parenthesizedExpression.Expression, data);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
-		{
-			TrackedVisit(invocationExpression.TargetObject, data);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(invocationExpression.Arguments);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		void PrintTypeArguments(List<TypeReference> typeArguments)
-		{
-			if (typeArguments != null && typeArguments.Count > 0) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				outputFormatter.PrintToken(Tokens.Of);
-				outputFormatter.Space();
-				AppendCommaSeparatedList(typeArguments);
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-		}
-		
-		public override object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
-		{
-			outputFormatter.PrintIdentifier(identifierExpression.Identifier);
-			PrintTypeArguments(identifierExpression.TypeArguments);
-			return null;
-		}
-		
-		public override object TrackedVisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data)
-		{
-			TrackedVisit(typeReferenceExpression.TypeReference, data);
-			return null;
-		}
-		
-		public override object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
-		{
-			switch (unaryOperatorExpression.Op) {
-				case UnaryOperatorType.Not:
-				case UnaryOperatorType.BitNot:
-					outputFormatter.PrintToken(Tokens.Not);
-					outputFormatter.Space();
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					return null;
-					
-				case UnaryOperatorType.Decrement:
-					outputFormatter.PrintText("System.Threading.Interlocked.Decrement(");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText(")");
-					return null;
-					
-				case UnaryOperatorType.Increment:
-					outputFormatter.PrintText("System.Threading.Interlocked.Increment(");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText(")");
-					return null;
-					
-				case UnaryOperatorType.Minus:
-					outputFormatter.PrintToken(Tokens.Minus);
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					return null;
-					
-				case UnaryOperatorType.Plus:
-					outputFormatter.PrintToken(Tokens.Plus);
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					return null;
-					
-				case UnaryOperatorType.PostDecrement:
-					outputFormatter.PrintText("System.Math.Max(System.Threading.Interlocked.Decrement(");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText("),");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText(" + 1)");
-					return null;
-					
-				case UnaryOperatorType.PostIncrement:
-					outputFormatter.PrintText("System.Math.Max(System.Threading.Interlocked.Increment(");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText("),");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText(" - 1)");
-					return null;
-					
-				case UnaryOperatorType.Dereference:
-					outputFormatter.PrintToken(Tokens.Times);
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					return null;
-				case UnaryOperatorType.AddressOf:
-					outputFormatter.PrintToken(Tokens.AddressOf);
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					return null;
-				default:
-					Error("unknown unary operator: " + unaryOperatorExpression.Op.ToString(), unaryOperatorExpression.StartLocation);
-					outputFormatter.PrintText(unaryOperatorExpression.Op.ToString());
-					outputFormatter.PrintText("(");
-					TrackedVisit(unaryOperatorExpression.Expression, data);
-					outputFormatter.PrintText(")");
-					return null;
-			}
-		}
-		
-		public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
-		{
-			int  op = 0;
-			bool unsupportedOpAssignment = false;
-			switch (assignmentExpression.Op) {
-				case AssignmentOperatorType.Assign:
-					op = Tokens.Assign;
-					break;
-				case AssignmentOperatorType.Add:
-					op = Tokens.PlusAssign;
-					break;
-				case AssignmentOperatorType.Subtract:
-					op = Tokens.MinusAssign;
-					break;
-				case AssignmentOperatorType.Multiply:
-					op = Tokens.TimesAssign;
-					break;
-				case AssignmentOperatorType.Divide:
-					op = Tokens.DivAssign;
-					break;
-				case AssignmentOperatorType.ShiftLeft:
-					op = Tokens.ShiftLeftAssign;
-					break;
-				case AssignmentOperatorType.ShiftRight:
-					op = Tokens.ShiftRightAssign;
-					break;
-					
-				case AssignmentOperatorType.ExclusiveOr:
-					op = Tokens.Xor;
-					unsupportedOpAssignment = true;
-					break;
-				case AssignmentOperatorType.Modulus:
-					op = Tokens.Mod;
-					unsupportedOpAssignment = true;
-					break;
-				case AssignmentOperatorType.BitwiseAnd:
-					op = Tokens.And;
-					unsupportedOpAssignment = true;
-					break;
-				case AssignmentOperatorType.BitwiseOr:
-					op = Tokens.Or;
-					unsupportedOpAssignment = true;
-					break;
-			}
-			
-			TrackedVisit(assignmentExpression.Left, data);
-			outputFormatter.Space();
-			
-			if (unsupportedOpAssignment) { // left = left OP right
-				outputFormatter.PrintToken(Tokens.Assign);
-				outputFormatter.Space();
-				TrackedVisit(assignmentExpression.Left, data);
-				outputFormatter.Space();
-			}
-			
-			outputFormatter.PrintToken(op);
-			outputFormatter.Space();
-			TrackedVisit(assignmentExpression.Right, data);
-			
-			return null;
-		}
-		
-		public override object TrackedVisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.GetType);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(typeOfExpression.TypeReference, data);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		public override object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
-		{
-			// assigning nothing to a generic type in VB compiles to a DefaultValueExpression
-			outputFormatter.PrintToken(Tokens.Nothing);
-			return null;
-		}
-		
-		public override object TrackedVisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.TypeOf);
-			outputFormatter.Space();
-			TrackedVisit(typeOfIsExpression.Expression, data);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Is);
-			outputFormatter.Space();
-			TrackedVisit(typeOfIsExpression.TypeReference, data);
-			return null;
-		}
-		
-		public override object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.AddressOf);
-			outputFormatter.Space();
-			TrackedVisit(addressOfExpression.Expression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitCastExpression(CastExpression castExpression, object data)
-		{
-			if (castExpression.CastType == CastType.TryCast) {
-				return PrintCast(Tokens.TryCast, castExpression);
-			}
-			if (castExpression.CastType == CastType.Cast || castExpression.CastTo.IsArrayType) {
-				return PrintCast(Tokens.DirectCast, castExpression);
-			}
-			switch (castExpression.CastTo.Type) {
-				case "System.Boolean":
-					outputFormatter.PrintToken(Tokens.CBool);
-					break;
-				case "System.Byte":
-					outputFormatter.PrintToken(Tokens.CByte);
-					break;
-				case "System.SByte":
-					outputFormatter.PrintToken(Tokens.CSByte);
-					break;
-				case "System.Char":
-					outputFormatter.PrintToken(Tokens.CChar);
-					break;
-				case "System.DateTime":
-					outputFormatter.PrintToken(Tokens.CDate);
-					break;
-				case "System.Decimal":
-					outputFormatter.PrintToken(Tokens.CDec);
-					break;
-				case "System.Double":
-					outputFormatter.PrintToken(Tokens.CDbl);
-					break;
-				case "System.Int16":
-					outputFormatter.PrintToken(Tokens.CShort);
-					break;
-				case "System.Int32":
-					outputFormatter.PrintToken(Tokens.CInt);
-					break;
-				case "System.Int64":
-					outputFormatter.PrintToken(Tokens.CLng);
-					break;
-				case "System.UInt16":
-					outputFormatter.PrintToken(Tokens.CUShort);
-					break;
-				case "System.UInt32":
-					outputFormatter.PrintToken(Tokens.CUInt);
-					break;
-				case "System.UInt64":
-					outputFormatter.PrintToken(Tokens.CULng);
-					break;
-				case "System.Object":
-					outputFormatter.PrintToken(Tokens.CObj);
-					break;
-				case "System.Single":
-					outputFormatter.PrintToken(Tokens.CSng);
-					break;
-				case "System.String":
-					outputFormatter.PrintToken(Tokens.CStr);
-					break;
-				default:
-					return PrintCast(Tokens.CType, castExpression);
-			}
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(castExpression.Expression, data);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		object PrintCast(int castToken, CastExpression castExpression)
-		{
-			outputFormatter.PrintToken(castToken);
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(castExpression.Expression, null);
-			outputFormatter.PrintToken(Tokens.Comma);
-			outputFormatter.Space();
-			TrackedVisit(castExpression.CastTo, null);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		public override object TrackedVisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Me);
-			return null;
-		}
-		
-		public override object TrackedVisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.MyBase);
-			return null;
-		}
-		
-		public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.New);
-			if (!objectCreateExpression.IsAnonymousType) {
-				outputFormatter.Space();
-				TrackedVisit(objectCreateExpression.CreateType, data);
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				AppendCommaSeparatedList(objectCreateExpression.Parameters);
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			}
-			CollectionInitializerExpression initializer = objectCreateExpression.ObjectInitializer;
-			if (!initializer.IsNull) {
-				outputFormatter.Space();
-				if (initializer.CreateExpressions.Any(ce => ce is MemberInitializerExpression))
-					outputFormatter.PrintToken(Tokens.With);
-				else
-					outputFormatter.PrintToken(Tokens.From);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
-				outputFormatter.IndentationLevel++;
-				for (int i = 0; i < initializer.CreateExpressions.Count; i++) {
-					Expression expr = initializer.CreateExpressions[i];
-					if (i > 0)
-						outputFormatter.PrintToken(Tokens.Comma);
-					outputFormatter.PrintLineContinuation();
-					outputFormatter.Indent();
-					TrackedVisit(expr, data);
-				}
-				outputFormatter.IndentationLevel--;
-				outputFormatter.PrintLineContinuation();
-				outputFormatter.Indent();
-				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.New);
-			outputFormatter.Space();
-			PrintTypeReferenceWithoutArray(arrayCreateExpression.CreateType);
-			
-			if (arrayCreateExpression.Arguments.Count > 0) {
-				outputFormatter.PrintToken(Tokens.OpenParenthesis);
-				AppendCommaSeparatedList(arrayCreateExpression.Arguments);
-				outputFormatter.PrintToken(Tokens.CloseParenthesis);
-				PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 1);
-			} else {
-				PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 0);
-			}
-			
-			outputFormatter.Space();
-			
-			if (arrayCreateExpression.ArrayInitializer.IsNull) {
-				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
-				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
-			} else {
-				TrackedVisit(arrayCreateExpression.ArrayInitializer, data);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression arrayInitializerExpression, object data)
-		{
-			outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
-			this.AppendCommaSeparatedList(arrayInitializerExpression.CreateExpressions);
-			outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
-			return null;
-		}
-		
-		public override object TrackedVisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data)
-		{
-			if (memberInitializerExpression.IsKey) {
-				outputFormatter.PrintToken(Tokens.Key);
-				outputFormatter.Space();
-			}
-			outputFormatter.PrintToken(Tokens.Dot);
-			outputFormatter.PrintIdentifier(memberInitializerExpression.Name);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Assign);
-			outputFormatter.Space();
-			TrackedVisit(memberInitializerExpression.Expression, data);
-			return null;
-		}
-		
-		public override object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
-		{
-			TrackedVisit(memberReferenceExpression.TargetObject, data);
-			outputFormatter.PrintToken(Tokens.Dot);
-			if (string.Equals(memberReferenceExpression.MemberName, "New", StringComparison.OrdinalIgnoreCase)
-			    && (memberReferenceExpression.TargetObject is BaseReferenceExpression || memberReferenceExpression.TargetObject is ThisReferenceExpression || memberReferenceExpression.TargetObject is ClassReferenceExpression))
-			{
-				outputFormatter.PrintToken(Tokens.New);
-			} else {
-				outputFormatter.PrintIdentifier(memberReferenceExpression.MemberName);
-			}
-			PrintTypeArguments(memberReferenceExpression.TypeArguments);
-			return null;
-		}
-		
-		public override object TrackedVisitDirectionExpression(DirectionExpression directionExpression, object data)
-		{
-			// VB does not need to specify the direction in method calls
-			TrackedVisit(directionExpression.Expression, data);
-			return null;
-		}
-		
-		
-		public override object TrackedVisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
-		{
-			outputFormatter.PrintText("If");
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			TrackedVisit(conditionalExpression.Condition, data);
-			outputFormatter.PrintToken(Tokens.Comma);
-			outputFormatter.Space();
-			TrackedVisit(conditionalExpression.TrueExpression, data);
-			outputFormatter.PrintToken(Tokens.Comma);
-			outputFormatter.Space();
-			TrackedVisit(conditionalExpression.FalseExpression, data);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			return null;
-		}
-		
-		#endregion
-		#endregion
-		
-		
-		void OutputModifier(ParameterModifiers modifier)
-		{
-			if ((modifier & ParameterModifiers.Optional) == ParameterModifiers.Optional) {
-				outputFormatter.PrintToken(Tokens.Optional);
-				outputFormatter.Space();
-			}
-			if ((modifier & ParameterModifiers.Ref) == ParameterModifiers.Ref
-			    || (modifier & ParameterModifiers.Out) == ParameterModifiers.Out) {
-				outputFormatter.PrintToken(Tokens.ByRef);
-				outputFormatter.Space();
-			}
-			if ((modifier & ParameterModifiers.Params) == ParameterModifiers.Params) {
-				outputFormatter.PrintToken(Tokens.ParamArray);
-				outputFormatter.Space();
-			}
-			if (prettyPrintOptions.OutputByValModifier &&
-			    (modifier & (ParameterModifiers.Params | ParameterModifiers.Ref)) == ParameterModifiers.None)
-			{
-				outputFormatter.PrintToken(Tokens.ByVal);
-				outputFormatter.Space();
-			}
-		}
-		
-		void OutputModifier(Modifiers modifier)
-		{
-			OutputModifier(modifier, false, false);
-		}
-		
-		void OutputModifier(Modifiers modifier, bool forTypeDecl, bool forFieldDecl)
-		{
-			if ((modifier & Modifiers.Public) == Modifiers.Public) {
-				outputFormatter.PrintToken(Tokens.Public);
-				outputFormatter.Space();
-			} else if ((modifier & Modifiers.Private) == Modifiers.Private) {
-				outputFormatter.PrintToken(Tokens.Private);
-				outputFormatter.Space();
-			} else if ((modifier & (Modifiers.Protected | Modifiers.Internal)) == (Modifiers.Protected | Modifiers.Internal)) {
-				outputFormatter.PrintToken(Tokens.Protected);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.Friend);
-				outputFormatter.Space();
-			} else if ((modifier & Modifiers.Internal) == Modifiers.Internal) {
-				outputFormatter.PrintToken(Tokens.Friend);
-				outputFormatter.Space();
-			} else if ((modifier & Modifiers.Protected) == Modifiers.Protected) {
-				outputFormatter.PrintToken(Tokens.Protected);
-				outputFormatter.Space();
-			}
-			
-			if ((modifier & Modifiers.Static) == Modifiers.Static) {
-				outputFormatter.PrintToken(Tokens.Shared);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Virtual) == Modifiers.Virtual) {
-				outputFormatter.PrintToken(Tokens.Overridable);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Abstract) == Modifiers.Abstract) {
-				if (forFieldDecl)
-					outputFormatter.PrintToken(Tokens.Dim);
-				else if (forTypeDecl)
-					outputFormatter.PrintToken(Tokens.MustInherit);
-				else
-					outputFormatter.PrintToken(Tokens.MustOverride);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Dim) == Modifiers.Dim) {
-				outputFormatter.PrintToken(Tokens.Dim);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Overloads) == Modifiers.Overloads) {
-				outputFormatter.PrintToken(Tokens.Overloads);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Override) == Modifiers.Override) {
-				outputFormatter.PrintToken(Tokens.Overrides);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.New) == Modifiers.New) {
-				outputFormatter.PrintToken(Tokens.Shadows);
-				outputFormatter.Space();
-			}
-			
-			if ((modifier & Modifiers.Sealed) == Modifiers.Sealed) {
-				outputFormatter.PrintToken(forTypeDecl ? Tokens.NotInheritable : Tokens.NotOverridable);
-				outputFormatter.Space();
-			}
-			
-			if ((modifier & Modifiers.ReadOnly) == Modifiers.ReadOnly) {
-				outputFormatter.PrintToken(Tokens.ReadOnly);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.WriteOnly) == Modifiers.WriteOnly) {
-				outputFormatter.PrintToken(Tokens.WriteOnly);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Const) == Modifiers.Const) {
-				outputFormatter.PrintToken(Tokens.Const);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.WithEvents) == Modifiers.WithEvents) {
-				outputFormatter.PrintToken(Tokens.WithEvents);
-				outputFormatter.Space();
-			}
-			if ((modifier & Modifiers.Partial) == Modifiers.Partial) {
-				outputFormatter.PrintToken(Tokens.Partial);
-				outputFormatter.Space();
-			}
-			
-			if ((modifier & Modifiers.Extern) == Modifiers.Extern) {
-				// not required in VB
-			}
-			
-			if ((modifier & Modifiers.Default) == Modifiers.Default) {
-				outputFormatter.PrintToken(Tokens.Default);
-				outputFormatter.Space();
-			}
-			
-			if ((modifier & Modifiers.Volatile) == Modifiers.Volatile) {
-				Error("'Volatile' modifier not convertable", Location.Empty);
-			}
-			
-			if ((modifier & Modifiers.Unsafe) == Modifiers.Unsafe) {
-				Error("'Unsafe' modifier not convertable", Location.Empty);
-			}
-		}
-		
-		public void AppendCommaSeparatedList<T>(ICollection<T> list) where T : class, INode
-		{
-			if (list != null) {
-				int i = 0;
-				foreach (T node in list) {
-					TrackedVisit(node, null);
-					if (i + 1 < list.Count) {
-						outputFormatter.PrintToken(Tokens.Comma);
-						outputFormatter.Space();
-						if ((i + 1) % 6 == 0) {
-							outputFormatter.PrintLineContinuation();
-							outputFormatter.Indent();
-							outputFormatter.PrintText("\t");
-						}
-					}
-					i++;
-				}
-			}
-		}
-		
-		void VisitAttributes(ICollection attributes, object data)
-		{
-			if (attributes == null) {
-				return;
-			}
-			foreach (AttributeSection section in attributes) {
-				if (string.Equals(section.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase))
-					continue;
-				TrackedVisit(section, data);
-			}
-		}
-		
-		void VisitReturnTypeAttributes(ICollection attributes, object data)
-		{
-			if (attributes == null) {
-				return;
-			}
-			printAttributeSectionInline = true;
-			foreach (AttributeSection section in attributes) {
-				if (string.Equals(section.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase)) {
-					TrackedVisit(section, data);
-				}
-			}
-			printAttributeSectionInline = false;
-		}
-		
-		public override object TrackedVisitLambdaExpression(LambdaExpression lambdaExpression, object data)
-		{
-			bool isSub = !lambdaExpression.ReturnType.IsNull &&
-				lambdaExpression.ReturnType.Type == "System.Void" && lambdaExpression.ReturnType.IsKeyword;
-			
-			if (isSub)
-				outputFormatter.PrintToken(Tokens.Sub);
-			else
-				outputFormatter.PrintToken(Tokens.Function);
-			
-			outputFormatter.PrintToken(Tokens.OpenParenthesis);
-			AppendCommaSeparatedList(lambdaExpression.Parameters);
-			outputFormatter.PrintToken(Tokens.CloseParenthesis);
-			
-			outputFormatter.Space();
-			
-			if (!lambdaExpression.ExpressionBody.IsNull) {
-				return lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
-			} else {
-				if (!isSub && !lambdaExpression.ReturnType.IsNull) {
-					outputFormatter.PrintToken(Tokens.As);
-					outputFormatter.Space();
-					TrackedVisit(lambdaExpression.ReturnType, data);
-				}
-				
-				if (lambdaExpression.StatementBody is BlockStatement)
-					outputFormatter.NewLine();
-				
-				TrackedVisit(lambdaExpression.StatementBody, data);
-				
-				if (lambdaExpression.StatementBody is BlockStatement) {
-					outputFormatter.NewLine();
-					outputFormatter.PrintToken(Tokens.End);
-					outputFormatter.Space();
-					if (isSub)
-						outputFormatter.PrintToken(Tokens.Sub);
-					else
-						outputFormatter.PrintToken(Tokens.Function);
-				}
-				
-				return null;
-			}
-		}
-		
-		public override object TrackedVisitQueryExpression(QueryExpression queryExpression, object data)
-		{
-			outputFormatter.IndentationLevel++;
-			for (int i = 0; i < queryExpression.Clauses.Count; i++) {
-				QueryExpressionClause clause = queryExpression.Clauses[i];
-				if (!clause.IsNull) {
-					if (i != 0) {
-						outputFormatter.PrintLineContinuation();
-						outputFormatter.Indent();
-					}
-					clause.AcceptVisitor(this, null);
-				}
-			}
-			outputFormatter.IndentationLevel--;
-			return null;
-		}
-		
-		void PrintClause(QueryExpressionClause clause)
-		{
-
-		}
-		
-		public override object TrackedVisitQueryExpressionFromClause(QueryExpressionFromClause fromClause, object data)
-		{
-			outputFormatter.PrintText("From");
-			outputFormatter.Space();
-			for (int i = 0; i < fromClause.Sources.Count; i++) {
-				CollectionRangeVariable clause = fromClause.Sources[i];
-				outputFormatter.PrintIdentifier(clause.Identifier);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.In);
-				outputFormatter.Space();
-				clause.Expression.AcceptVisitor(this, data);
-				if (i < fromClause.Sources.Count - 1)
-					outputFormatter.PrintToken(Tokens.Comma);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitQueryExpressionJoinClause(QueryExpressionJoinClause joinClause, object data)
-		{
-			outputFormatter.PrintText("Join");
-			outputFormatter.Space();
-			CollectionRangeVariable clause = joinClause.Source;
-			outputFormatter.PrintIdentifier(clause.Identifier);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.In);
-			outputFormatter.Space();
-			clause.Expression.AcceptVisitor(this, data);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.On);
-			outputFormatter.Space();
-			joinClause.OnExpression.AcceptVisitor(this, data);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Assign);
-			outputFormatter.Space();
-			joinClause.EqualsExpression.AcceptVisitor(this, data);
-			if (!string.IsNullOrEmpty(joinClause.IntoIdentifier)) {
-				outputFormatter.Space();
-				outputFormatter.PrintText("Into");
-				outputFormatter.Space();
-				outputFormatter.PrintIdentifier(joinClause.IntoIdentifier);
-			}
-			return null;
-		}
-		
-//		void VisitQueryExpressionFromOrJoinClause(QueryExpressionFromOrJoinClause clause, object data)
+//	public sealed class VBNetOutputVisitor : NodeTrackingAstVisitor, IOutputDomVisitor
+//	{
+//		Errors                  errors             = new Errors();
+//		VBNetOutputFormatter    outputFormatter;
+//		VBNetPrettyPrintOptions prettyPrintOptions = new VBNetPrettyPrintOptions();
+//		TypeDeclaration         currentType;
+//		
+//		Stack<int> exitTokenStack = new Stack<int>();
+//		
+//		public string Text {
+//			get {
+//				return outputFormatter.Text;
+//			}
+//		}
+//		
+//		public Errors Errors {
+//			get {
+//				return errors;
+//			}
+//		}
+//		
+//		AbstractPrettyPrintOptions IOutputDomVisitor.Options {
+//			get { return prettyPrintOptions; }
+//		}
+//		
+//		public VBNetPrettyPrintOptions Options {
+//			get { return prettyPrintOptions; }
+//		}
+//		
+//		public IOutputFormatter OutputFormatter {
+//			get {
+//				return outputFormatter;
+//			}
+//		}
+//		
+//		public VBNetOutputVisitor()
+//		{
+//			outputFormatter = new VBNetOutputFormatter(prettyPrintOptions);
+//		}
+//		
+//		public event Action<INode> BeforeNodeVisit;
+//		public event Action<INode> AfterNodeVisit;
+//		
+//		protected override void BeginVisit(INode node)
+//		{
+//			if (BeforeNodeVisit != null) {
+//				BeforeNodeVisit(node);
+//			}
+//			base.BeginVisit(node);
+//		}
+//		
+//		protected override void EndVisit(INode node)
+//		{
+//			base.EndVisit(node);
+//			if (AfterNodeVisit != null) {
+//				AfterNodeVisit(node);
+//			}
+//		}
+//		
+//		object TrackedVisit(INode node, object data)
+//		{
+//			return node.AcceptVisitor(this, data);
+//		}
+//		
+//		void Error(string text, Location position)
+//		{
+//			errors.Error(position.Line, position.Column, text);
+//		}
+//		
+//		void UnsupportedNode(INode node)
+//		{
+//			Error(node.GetType().Name + " is unsupported", node.StartLocation);
+//		}
+//		
+//		#region ICSharpCode.NRefactory.Parser.IAstVisitor interface implementation
+//		public override object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data)
+//		{
+//			compilationUnit.AcceptChildren(this, data);
+//			outputFormatter.EndFile();
+//			return null;
+//		}
+//		
+//		/// <summary>
+//		/// Converts type name to primitive type name. Returns typeString if typeString is not
+//		/// a primitive type.
+//		/// </summary>
+//		static string ConvertTypeString(string typeString)
+//		{
+//			string primitiveType;
+//			if (TypeReference.PrimitiveTypesVBReverse.TryGetValue(typeString, out primitiveType))
+//				return primitiveType;
+//			else
+//				return typeString;
+//		}
+//
+//		public override object TrackedVisitTypeReference(TypeReference typeReference, object data)
+//		{
+//			if (typeReference == TypeReference.ClassConstraint) {
+//				outputFormatter.PrintToken(Tokens.Class);
+//			} else if (typeReference == TypeReference.StructConstraint) {
+//				outputFormatter.PrintToken(Tokens.Structure);
+//			} else if (typeReference == TypeReference.NewConstraint) {
+//				outputFormatter.PrintToken(Tokens.New);
+//			} else {
+//				PrintTypeReferenceWithoutArray(typeReference);
+//				if (typeReference.IsArrayType) {
+//					PrintArrayRank(typeReference.RankSpecifier, 0);
+//				}
+//			}
+//			return null;
+//		}
+//		
+//		void PrintTypeReferenceWithoutArray(TypeReference typeReference)
+//		{
+//			if (typeReference.IsGlobal) {
+//				outputFormatter.PrintToken(Tokens.Global);
+//				outputFormatter.PrintToken(Tokens.Dot);
+//			}
+//			bool printGenerics = true;
+//			if (typeReference.IsKeyword) {
+//				outputFormatter.PrintText(ConvertTypeString(typeReference.Type));
+//			} else {
+//				outputFormatter.PrintIdentifier(typeReference.Type);
+//			}
+//			if (printGenerics && typeReference.GenericTypes != null && typeReference.GenericTypes.Count > 0) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				outputFormatter.PrintToken(Tokens.Of);
+//				outputFormatter.Space();
+//				AppendCommaSeparatedList(typeReference.GenericTypes);
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//			for (int i = 0; i < typeReference.PointerNestingLevel; ++i) {
+//				outputFormatter.PrintToken(Tokens.Times);
+//			}
+//		}
+//		
+//		void PrintArrayRank(int[] rankSpecifier, int startRank)
+//		{
+//			for (int i = startRank; i < rankSpecifier.Length; ++i) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				for (int j = 0; j < rankSpecifier[i]; ++j) {
+//					outputFormatter.PrintToken(Tokens.Comma);
+//				}
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//		}
+//		
+//		public override object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data)
+//		{
+//			TrackedVisit(innerClassTypeReference.BaseType, data);
+//			outputFormatter.PrintToken(Tokens.Dot);
+//			return VisitTypeReference((TypeReference)innerClassTypeReference, data);
+//		}
+//		
+//		#region Global scope
+//		bool printAttributeSectionInline; // is set to true when printing parameter's attributes
+//		
+//		public override object TrackedVisitAttributeSection(AttributeSection attributeSection, object data)
+//		{
+//			if (!printAttributeSectionInline)
+//				outputFormatter.Indent();
+//			outputFormatter.PrintText("<");
+//			if (!string.IsNullOrEmpty(attributeSection.AttributeTarget) && !string.Equals(attributeSection.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase)) {
+//				outputFormatter.PrintText(char.ToUpperInvariant(attributeSection.AttributeTarget[0]) + attributeSection.AttributeTarget.Substring(1));
+//				outputFormatter.PrintToken(Tokens.Colon);
+//				outputFormatter.Space();
+//			}
+//			Debug.Assert(attributeSection.Attributes != null);
+//			AppendCommaSeparatedList(attributeSection.Attributes);
+//			
+//			outputFormatter.PrintText(">");
+//			
+//			if ("assembly".Equals(attributeSection.AttributeTarget, StringComparison.InvariantCultureIgnoreCase)
+//			    || "module".Equals(attributeSection.AttributeTarget, StringComparison.InvariantCultureIgnoreCase)) {
+//				outputFormatter.NewLine();
+//			} else {
+//				if (printAttributeSectionInline)
+//					outputFormatter.Space();
+//				else
+//					outputFormatter.PrintLineContinuation();
+//			}
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data)
+//		{
+//			outputFormatter.PrintIdentifier(attribute.Type);
+//			if (attribute.PositionalArguments.Count > 0 || attribute.NamedArguments.Count > 0) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				AppendCommaSeparatedList(attribute.PositionalArguments);
+//				
+//				if (attribute.NamedArguments.Count > 0) {
+//					if (attribute.PositionalArguments.Count > 0) {
+//						outputFormatter.PrintToken(Tokens.Comma);
+//						outputFormatter.Space();
+//					}
+//					AppendCommaSeparatedList(attribute.NamedArguments);
+//				}
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data)
+//		{
+//			outputFormatter.PrintIdentifier(namedArgumentExpression.Name);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Colon);
+//			outputFormatter.PrintToken(Tokens.Assign);
+//			outputFormatter.Space();
+//			TrackedVisit(namedArgumentExpression.Expression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitUsing(ImportsClause @using, object data)
+//		{
+//			Debug.Fail("Should never be called. The usings should be handled in Visit(UsingDeclaration)");
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitUsingDeclaration(ImportsStatement usingDeclaration, object data)
+//		{
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.Imports);
+//			outputFormatter.Space();
+//			for (int i = 0; i < usingDeclaration.ImportsClauses.Count; ++i) {
+//				outputFormatter.PrintIdentifier(((ImportsClause)usingDeclaration.ImportsClauses[i]).Name);
+//				if (((ImportsClause)usingDeclaration.ImportsClauses[i]).IsAlias) {
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.Assign);
+//					outputFormatter.Space();
+//					TrackedVisit(((ImportsClause)usingDeclaration.ImportsClauses[i]).Alias, data);
+//				}
+//				if (i + 1 < usingDeclaration.ImportsClauses.Count) {
+//					outputFormatter.PrintToken(Tokens.Comma);
+//					outputFormatter.Space();
+//				}
+//			}
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
+//		{
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.Namespace);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(namespaceDeclaration.Name);
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			namespaceDeclaration.AcceptChildren(this, data);
+//			--outputFormatter.IndentationLevel;
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Namespace);
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		static int GetTypeToken(TypeDeclaration typeDeclaration)
+//		{
+//			switch (typeDeclaration.Type) {
+//				case ClassType.Class:
+//					return Tokens.Class;
+//				case ClassType.Enum:
+//					return Tokens.Enum;
+//				case ClassType.Interface:
+//					return Tokens.Interface;
+//				case ClassType.Struct:
+//					return Tokens.Structure;
+//				case ClassType.Module:
+//					return Tokens.Module;
+//				default:
+//					return Tokens.Class;
+//			}
+//		}
+//		
+//		void PrintTemplates(List<TemplateDefinition> templates)
+//		{
+//			if (templates != null && templates.Count > 0) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				outputFormatter.PrintToken(Tokens.Of);
+//				outputFormatter.Space();
+//				AppendCommaSeparatedList(templates);
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//		}
+//		
+//		public override object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
+//		{
+//			VisitAttributes(typeDeclaration.Attributes, data);
+//			
+//			outputFormatter.Indent();
+//			OutputModifier(typeDeclaration.Modifier, true, false);
+//			
+//			int typeToken = GetTypeToken(typeDeclaration);
+//			outputFormatter.PrintToken(typeToken);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(typeDeclaration.Name);
+//			
+//			PrintTemplates(typeDeclaration.Templates);
+//			
+//			if (typeDeclaration.Type == ClassType.Enum
+//			    && typeDeclaration.BaseTypes != null && typeDeclaration.BaseTypes.Count > 0)
+//			{
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				foreach (TypeReference baseTypeRef in typeDeclaration.BaseTypes) {
+//					TrackedVisit(baseTypeRef, data);
+//				}
+//			}
+//			
+//			outputFormatter.NewLine();
+//			++outputFormatter.IndentationLevel;
+//			
+//			if (typeDeclaration.BaseTypes != null && typeDeclaration.Type != ClassType.Enum) {
+//				foreach (TypeReference baseTypeRef in typeDeclaration.BaseTypes) {
+//					outputFormatter.Indent();
+//					
+//					string baseType = baseTypeRef.Type;
+//					if (baseType.IndexOf('.') >= 0) {
+//						baseType = baseType.Substring(baseType.LastIndexOf('.') + 1);
+//					}
+//					bool baseTypeIsInterface = baseType.Length >= 2 && baseType[0] == 'I' && Char.IsUpper(baseType[1]);
+//					
+//					if (!baseTypeIsInterface || typeDeclaration.Type == ClassType.Interface) {
+//						outputFormatter.PrintToken(Tokens.Inherits);
+//					} else {
+//						outputFormatter.PrintToken(Tokens.Implements);
+//					}
+//					outputFormatter.Space();
+//					TrackedVisit(baseTypeRef, data);
+//					outputFormatter.NewLine();
+//				}
+//			}
+//			
+//			TypeDeclaration oldType = currentType;
+//			currentType = typeDeclaration;
+//			
+//			if (typeDeclaration.Type == ClassType.Enum) {
+//				OutputEnumMembers(typeDeclaration, data);
+//			} else {
+//				typeDeclaration.AcceptChildren(this, data);
+//			}
+//			currentType = oldType;
+//			
+//			--outputFormatter.IndentationLevel;
+//			
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(typeToken);
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		void OutputEnumMembers(TypeDeclaration typeDeclaration, object data)
+//		{
+//			foreach (FieldDeclaration fieldDeclaration in typeDeclaration.Children) {
+//				BeginVisit(fieldDeclaration);
+//				VariableDeclaration f = (VariableDeclaration)fieldDeclaration.Fields[0];
+//				VisitAttributes(fieldDeclaration.Attributes, data);
+//				outputFormatter.Indent();
+//				outputFormatter.PrintIdentifier(f.Name);
+//				if (f.Initializer != null && !f.Initializer.IsNull) {
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.Assign);
+//					outputFormatter.Space();
+//					TrackedVisit(f.Initializer, data);
+//				}
+//				outputFormatter.NewLine();
+//				EndVisit(fieldDeclaration);
+//			}
+//		}
+//		
+//		public override object TrackedVisitTemplateDefinition(TemplateDefinition templateDefinition, object data)
+//		{
+//			VisitAttributes(templateDefinition.Attributes, data);
+//			switch (templateDefinition.VarianceModifier) {
+//				case VarianceModifier.Invariant:
+//					// nothing
+//					break;
+//				case VarianceModifier.Covariant:
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.Out);
+//					outputFormatter.Space();
+//					break;
+//				case VarianceModifier.Contravariant:
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.In);
+//					outputFormatter.Space();
+//					break;
+//				default:
+//					throw new Exception("Invalid value for VarianceModifier");
+//			}
+//			outputFormatter.PrintIdentifier(templateDefinition.Name);
+//			if (templateDefinition.Bases.Count > 0) {
+//				outputFormatter.PrintText(" As ");
+//				VisitReturnTypeAttributes(templateDefinition.Attributes, data);
+//				if (templateDefinition.Bases.Count == 1) {
+//					TrackedVisit(templateDefinition.Bases[0], data);
+//				} else {
+//					outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
+//					AppendCommaSeparatedList(templateDefinition.Bases);
+//					outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
+//				}
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
+//		{
+//			VisitAttributes(delegateDeclaration.Attributes, data);
+//			
+//			outputFormatter.Indent();
+//			OutputModifier(delegateDeclaration.Modifier, true, false);
+//			outputFormatter.PrintToken(Tokens.Delegate);
+//			outputFormatter.Space();
+//			
+//			bool isFunction = (delegateDeclaration.ReturnType.Type != "System.Void");
+//			if (isFunction) {
+//				outputFormatter.PrintToken(Tokens.Function);
+//				outputFormatter.Space();
+//			} else {
+//				outputFormatter.PrintToken(Tokens.Sub);
+//				outputFormatter.Space();
+//			}
+//			outputFormatter.PrintIdentifier(delegateDeclaration.Name);
+//			
+//			PrintTemplates(delegateDeclaration.Templates);
+//			
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(delegateDeclaration.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			if (isFunction) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				VisitReturnTypeAttributes(delegateDeclaration.Attributes, data);
+//				TrackedVisit(delegateDeclaration.ReturnType, data);
+//			}
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitOptionDeclaration(OptionDeclaration optionDeclaration, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Option);
+//			outputFormatter.Space();
+//			switch (optionDeclaration.OptionType) {
+//				case OptionType.Strict:
+//					outputFormatter.PrintToken(Tokens.Strict);
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(optionDeclaration.OptionValue ? Tokens.On : Tokens.Off);
+//					break;
+//				case OptionType.Explicit:
+//					outputFormatter.PrintToken(Tokens.Explicit);
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(optionDeclaration.OptionValue ? Tokens.On : Tokens.Off);
+//					break;
+//				case OptionType.Infer:
+//					outputFormatter.PrintToken(Tokens.Infer);
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(optionDeclaration.OptionValue ? Tokens.On : Tokens.Off);
+//					break;
+//				case OptionType.CompareBinary:
+//					outputFormatter.PrintToken(Tokens.Compare);
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.Binary);
+//					break;
+//				case OptionType.CompareText:
+//					outputFormatter.PrintToken(Tokens.Compare);
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.Text);
+//					break;
+//			}
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		#endregion
+//		
+//		#region Type level
+//		TypeReference currentVariableType;
+//		public override object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
+//		{
+//			
+//			VisitAttributes(fieldDeclaration.Attributes, data);
+//			outputFormatter.Indent();
+//			if (fieldDeclaration.Modifier == Modifiers.None) {
+//				outputFormatter.PrintToken(Tokens.Private);
+//				outputFormatter.Space();
+//			} else {
+//				OutputModifier(fieldDeclaration.Modifier, false, true);
+//			}
+//			currentVariableType = fieldDeclaration.TypeReference;
+//			AppendCommaSeparatedList(fieldDeclaration.Fields);
+//			currentVariableType = null;
+//			
+//			outputFormatter.NewLine();
+//
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
+//		{
+//			outputFormatter.PrintIdentifier(variableDeclaration.Name);
+//			
+//			TypeReference varType = currentVariableType;
+//			if (varType != null && varType.IsNull)
+//				varType = null;
+//			if (varType == null && !variableDeclaration.TypeReference.IsNull)
+//				varType = variableDeclaration.TypeReference;
+//			
+//			if (varType != null) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				ObjectCreateExpression init = variableDeclaration.Initializer as ObjectCreateExpression;
+//				if (init != null && TypeReference.AreEqualReferences(init.CreateType, varType)) {
+//					TrackedVisit(variableDeclaration.Initializer, data);
+//					return null;
+//				} else {
+//					TrackedVisit(varType, data);
+//				}
+//			}
+//			
+//			if (!variableDeclaration.Initializer.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Assign);
+//				outputFormatter.Space();
+//				TrackedVisit(variableDeclaration.Initializer, data);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
+//		{
+//			VisitAttributes(propertyDeclaration.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(propertyDeclaration.Modifier);
+//			
+//			if ((propertyDeclaration.Modifier & (Modifiers.ReadOnly | Modifiers.WriteOnly)) == Modifiers.None) {
+//				if (propertyDeclaration.IsReadOnly) {
+//					outputFormatter.PrintToken(Tokens.ReadOnly);
+//					outputFormatter.Space();
+//				} else if (propertyDeclaration.IsWriteOnly) {
+//					outputFormatter.PrintToken(Tokens.WriteOnly);
+//					outputFormatter.Space();
+//				}
+//			}
+//			
+//			outputFormatter.PrintToken(Tokens.Property);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(propertyDeclaration.Name);
+//			
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(propertyDeclaration.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			if (!propertyDeclaration.TypeReference.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				
+//				VisitReturnTypeAttributes(propertyDeclaration.Attributes, data);
+//				
+//				ObjectCreateExpression init = propertyDeclaration.Initializer as ObjectCreateExpression;
+//				if (init != null && TypeReference.AreEqualReferences(init.CreateType, propertyDeclaration.TypeReference)) {
+//					TrackedVisit(propertyDeclaration.Initializer, data);
+//				} else {
+//					TrackedVisit(propertyDeclaration.TypeReference, data);
+//				}
+//			}
+//			
+//			PrintInterfaceImplementations(propertyDeclaration.InterfaceImplementations);
+//			
+//			if (!propertyDeclaration.Initializer.IsNull && !(propertyDeclaration.Initializer is ObjectCreateExpression)) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Assign);
+//				outputFormatter.Space();
+//				TrackedVisit(propertyDeclaration.Initializer, data);
+//			}
+//			
+//			outputFormatter.NewLine();
+//			
+//			if (!IsAbstract(propertyDeclaration) && (propertyDeclaration.GetRegion.Block != NullBlockStatement.Instance  || propertyDeclaration.SetRegion.Block != NullBlockStatement.Instance)) {
+//				outputFormatter.IsInMemberBody = true;
+//				++outputFormatter.IndentationLevel;
+//				exitTokenStack.Push(Tokens.Property);
+//				TrackedVisit(propertyDeclaration.GetRegion, data);
+//				TrackedVisit(propertyDeclaration.SetRegion, data);
+//				exitTokenStack.Pop();
+//				--outputFormatter.IndentationLevel;
+//				outputFormatter.IsInMemberBody = false;
+//				
+//				outputFormatter.Indent();
+//				outputFormatter.PrintToken(Tokens.End);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Property);
+//				outputFormatter.NewLine();
+//			}
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data)
+//		{
+//			VisitAttributes(propertyGetRegion.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(propertyGetRegion.Modifier);
+//			outputFormatter.PrintToken(Tokens.Get);
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			TrackedVisit(propertyGetRegion.Block, data);
+//			--outputFormatter.IndentationLevel;
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Get);
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitPropertySetRegion(PropertySetRegion propertySetRegion, object data)
+//		{
+//			VisitAttributes(propertySetRegion.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(propertySetRegion.Modifier);
+//			outputFormatter.PrintToken(Tokens.Set);
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			TrackedVisit(propertySetRegion.Block, data);
+//			--outputFormatter.IndentationLevel;
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Set);
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		TypeReference currentEventType = null;
+//		public override object TrackedVisitEventDeclaration(EventDeclaration eventDeclaration, object data)
+//		{
+//			bool customEvent = eventDeclaration.HasAddRegion  || eventDeclaration.HasRemoveRegion;
+//			
+//			VisitAttributes(eventDeclaration.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(eventDeclaration.Modifier);
+//			if (customEvent) {
+//				outputFormatter.PrintText("Custom");
+//				outputFormatter.Space();
+//			}
+//			
+//			outputFormatter.PrintToken(Tokens.Event);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(eventDeclaration.Name);
+//			
+//			if (eventDeclaration.Parameters.Count > 0) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				this.AppendCommaSeparatedList(eventDeclaration.Parameters);
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//			if (!eventDeclaration.TypeReference.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				VisitReturnTypeAttributes(eventDeclaration.Attributes, data);
+//				TrackedVisit(eventDeclaration.TypeReference, data);
+//			}
+//			
+//			PrintInterfaceImplementations(eventDeclaration.InterfaceImplementations);
+//			
+//			if (!eventDeclaration.Initializer.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Assign);
+//				outputFormatter.Space();
+//				TrackedVisit(eventDeclaration.Initializer, data);
+//			}
+//			
+//			outputFormatter.NewLine();
+//			
+//			if (customEvent) {
+//				++outputFormatter.IndentationLevel;
+//				currentEventType = eventDeclaration.TypeReference;
+//				exitTokenStack.Push(Tokens.Sub);
+//				TrackedVisit(eventDeclaration.AddRegion, data);
+//				TrackedVisit(eventDeclaration.RemoveRegion, data);
+//				exitTokenStack.Pop();
+//				--outputFormatter.IndentationLevel;
+//				
+//				outputFormatter.Indent();
+//				outputFormatter.PrintToken(Tokens.End);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Event);
+//				outputFormatter.NewLine();
+//			}
+//			return null;
+//		}
+//		
+//		void PrintInterfaceImplementations(IList<InterfaceImplementation> list)
+//		{
+//			if (list == null || list.Count == 0)
+//				return;
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Implements);
+//			for (int i = 0; i < list.Count; i++) {
+//				if (i > 0)
+//					outputFormatter.PrintToken(Tokens.Comma);
+//				outputFormatter.Space();
+//				TrackedVisit(list[i].InterfaceType, null);
+//				outputFormatter.PrintToken(Tokens.Dot);
+//				outputFormatter.PrintIdentifier(list[i].MemberName);
+//			}
+//		}
+//		
+//		public override object TrackedVisitEventAddRegion(EventAddRegion eventAddRegion, object data)
+//		{
+//			VisitAttributes(eventAddRegion.Attributes, data);
+//			outputFormatter.Indent();
+//			outputFormatter.PrintText("AddHandler(");
+//			if (eventAddRegion.Parameters.Count == 0) {
+//				outputFormatter.PrintToken(Tokens.ByVal);
+//				outputFormatter.Space();
+//				outputFormatter.PrintIdentifier("value");
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				TrackedVisit(currentEventType, data);
+//			} else {
+//				this.AppendCommaSeparatedList(eventAddRegion.Parameters);
+//			}
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			TrackedVisit(eventAddRegion.Block, data);
+//			--outputFormatter.IndentationLevel;
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintText("AddHandler");
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data)
+//		{
+//			VisitAttributes(eventRemoveRegion.Attributes, data);
+//			outputFormatter.Indent();
+//			outputFormatter.PrintText("RemoveHandler");
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			if (eventRemoveRegion.Parameters.Count == 0) {
+//				outputFormatter.PrintToken(Tokens.ByVal);
+//				outputFormatter.Space();
+//				outputFormatter.PrintIdentifier("value");
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				TrackedVisit(currentEventType, data);
+//			} else {
+//				this.AppendCommaSeparatedList(eventRemoveRegion.Parameters);
+//			}
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			TrackedVisit(eventRemoveRegion.Block, data);
+//			--outputFormatter.IndentationLevel;
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintText("RemoveHandler");
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data)
+//		{
+//			VisitAttributes(eventRaiseRegion.Attributes, data);
+//			outputFormatter.Indent();
+//			outputFormatter.PrintText("RaiseEvent");
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			if (eventRaiseRegion.Parameters.Count == 0) {
+//				outputFormatter.PrintToken(Tokens.ByVal);
+//				outputFormatter.Space();
+//				outputFormatter.PrintIdentifier("value");
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				TrackedVisit(currentEventType, data);
+//			} else {
+//				this.AppendCommaSeparatedList(eventRaiseRegion.Parameters);
+//			}
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			TrackedVisit(eventRaiseRegion.Block, data);
+//			--outputFormatter.IndentationLevel;
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintText("RaiseEvent");
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)
+//		{
+//			printAttributeSectionInline = true;
+//			VisitAttributes(parameterDeclarationExpression.Attributes, data);
+//			printAttributeSectionInline = false;
+//			OutputModifier(parameterDeclarationExpression.ParamModifier);
+//			outputFormatter.PrintIdentifier(parameterDeclarationExpression.ParameterName);
+//			if (!parameterDeclarationExpression.TypeReference.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				VisitReturnTypeAttributes(parameterDeclarationExpression.Attributes, data);
+//				TrackedVisit(parameterDeclarationExpression.TypeReference, data);
+//			}
+//			if (!parameterDeclarationExpression.DefaultValue.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Assign);
+//				outputFormatter.Space();
+//				TrackedVisit(parameterDeclarationExpression.DefaultValue, data);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
+//		{
+//			VisitAttributes(methodDeclaration.Attributes, data);
+//			if (methodDeclaration.IsExtensionMethod) {
+//				outputFormatter.Indent();
+//				outputFormatter.PrintText("<System.Runtime.CompilerServices.Extension> _");
+//				outputFormatter.NewLine();
+//			}
+//			outputFormatter.Indent();
+//			OutputModifier(methodDeclaration.Modifier);
+//			
+//			bool isSub = methodDeclaration.TypeReference.IsNull ||
+//				methodDeclaration.TypeReference.Type == "System.Void";
+//			
+//			if (isSub) {
+//				outputFormatter.PrintToken(Tokens.Sub);
+//			} else {
+//				outputFormatter.PrintToken(Tokens.Function);
+//			}
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(methodDeclaration.Name);
+//			
+//			PrintTemplates(methodDeclaration.Templates);
+//			
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(methodDeclaration.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			if (!isSub) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				VisitReturnTypeAttributes(methodDeclaration.Attributes, data);
+//				TrackedVisit(methodDeclaration.TypeReference, data);
+//			}
+//			
+//			PrintInterfaceImplementations(methodDeclaration.InterfaceImplementations);
+//			
+//			if (methodDeclaration.HandlesClause.Count > 0) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Handles);
+//				for (int i = 0; i < methodDeclaration.HandlesClause.Count; i++) {
+//					if (i > 0)
+//						outputFormatter.PrintToken(Tokens.Comma);
+//					outputFormatter.Space();
+//					outputFormatter.PrintText(methodDeclaration.HandlesClause[i]);
+//				}
+//			}
+//			
+//			outputFormatter.NewLine();
+//			
+//			if (!IsAbstract(methodDeclaration)) {
+//				outputFormatter.IsInMemberBody = true;
+//				BeginVisit(methodDeclaration.Body);
+//				++outputFormatter.IndentationLevel;
+//				exitTokenStack.Push(isSub ? Tokens.Sub : Tokens.Function);
+//				// we're doing the tracking manually using BeginVisit/EndVisit, so call Tracked... directly
+//				this.TrackedVisitBlockStatement(methodDeclaration.Body, data);
+//				exitTokenStack.Pop();
+//				--outputFormatter.IndentationLevel;
+//				
+//				outputFormatter.Indent();
+//				outputFormatter.PrintToken(Tokens.End);
+//				outputFormatter.Space();
+//				if (isSub) {
+//					outputFormatter.PrintToken(Tokens.Sub);
+//				} else {
+//					outputFormatter.PrintToken(Tokens.Function);
+//				}
+//				outputFormatter.NewLine();
+//				EndVisit(methodDeclaration.Body);
+//				outputFormatter.IsInMemberBody = false;
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data)
+//		{
+//			throw new InvalidOperationException();
+//		}
+//		
+//		bool IsAbstract(AttributedNode node)
+//		{
+//			if ((node.Modifier & Modifiers.Abstract) == Modifiers.Abstract)
+//				return true;
+//			return currentType != null && currentType.Type == ClassType.Interface;
+//		}
+//		
+//		public override object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
+//		{
+//			VisitAttributes(constructorDeclaration.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(constructorDeclaration.Modifier);
+//			outputFormatter.PrintToken(Tokens.Sub);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.New);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(constructorDeclaration.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			outputFormatter.NewLine();
+//			
+//			outputFormatter.IsInMemberBody = true;
+//			++outputFormatter.IndentationLevel;
+//			exitTokenStack.Push(Tokens.Sub);
+//			
+//			TrackedVisit(constructorDeclaration.ConstructorInitializer, data);
+//			
+//			TrackedVisit(constructorDeclaration.Body, data);
+//			exitTokenStack.Pop();
+//			--outputFormatter.IndentationLevel;
+//			outputFormatter.IsInMemberBody = false;
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Sub);
+//			outputFormatter.NewLine();
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data)
+//		{
+//			outputFormatter.Indent();
+//			if (constructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This) {
+//				outputFormatter.PrintToken(Tokens.Me);
+//			} else {
+//				outputFormatter.PrintToken(Tokens.MyBase);
+//			}
+//			outputFormatter.PrintToken(Tokens.Dot);
+//			outputFormatter.PrintToken(Tokens.New);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(constructorInitializer.Arguments);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			outputFormatter.NewLine();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data)
+//		{
+//			VisitAttributes(operatorDeclaration.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(operatorDeclaration.Modifier);
+//			
+//			if (operatorDeclaration.IsConversionOperator) {
+//				if (operatorDeclaration.ConversionType == ConversionType.Implicit) {
+//					outputFormatter.PrintToken(Tokens.Widening);
+//				} else {
+//					outputFormatter.PrintToken(Tokens.Narrowing);
+//				}
+//				outputFormatter.Space();
+//			}
+//			
+//			outputFormatter.PrintToken(Tokens.Operator);
+//			outputFormatter.Space();
+//			
+//			int op = -1;
+//			
+//			switch(operatorDeclaration.OverloadableOperator)
+//			{
+//				case OverloadableOperatorType.Add:
+//				case OverloadableOperatorType.UnaryPlus:
+//					op = Tokens.Plus;
+//					break;
+//				case OverloadableOperatorType.UnaryMinus:
+//				case OverloadableOperatorType.Subtract:
+//					op = Tokens.Minus;
+//					break;
+//				case OverloadableOperatorType.Multiply:
+//					op = Tokens.Times;
+//					break;
+//				case OverloadableOperatorType.Divide:
+//					op = Tokens.Div;
+//					break;
+//				case OverloadableOperatorType.Modulus:
+//					op = Tokens.Mod;
+//					break;
+//				case OverloadableOperatorType.Concat:
+//					op = Tokens.ConcatString;
+//					break;
+//				case OverloadableOperatorType.Not:
+//					op = Tokens.Not;
+//					break;
+//				case OverloadableOperatorType.BitNot:
+//					op = Tokens.Not;
+//					break;
+//				case OverloadableOperatorType.BitwiseAnd:
+//					op = Tokens.And;
+//					break;
+//				case OverloadableOperatorType.BitwiseOr:
+//					op = Tokens.Or;
+//					break;
+//				case OverloadableOperatorType.ExclusiveOr:
+//					op = Tokens.Xor;
+//					break;
+//				case OverloadableOperatorType.ShiftLeft:
+//					op = Tokens.ShiftLeft;
+//					break;
+//				case OverloadableOperatorType.ShiftRight:
+//					op = Tokens.ShiftRight;
+//					break;
+//				case OverloadableOperatorType.GreaterThan:
+//					op = Tokens.GreaterThan;
+//					break;
+//				case OverloadableOperatorType.GreaterThanOrEqual:
+//					op = Tokens.GreaterEqual;
+//					break;
+//				case OverloadableOperatorType.Equality:
+//					op = Tokens.Assign;
+//					break;
+//				case OverloadableOperatorType.InEquality:
+//					op = Tokens.NotEqual;
+//					break;
+//				case OverloadableOperatorType.LessThan:
+//					op = Tokens.LessThan;
+//					break;
+//				case OverloadableOperatorType.LessThanOrEqual:
+//					op = Tokens.LessEqual;
+//					break;
+//				case OverloadableOperatorType.Increment:
+//					Error("Increment operator is not supported in Visual Basic", operatorDeclaration.StartLocation);
+//					break;
+//				case OverloadableOperatorType.Decrement:
+//					Error("Decrement operator is not supported in Visual Basic", operatorDeclaration.StartLocation);
+//					break;
+//				case OverloadableOperatorType.IsTrue:
+//					outputFormatter.PrintText("IsTrue");
+//					break;
+//				case OverloadableOperatorType.IsFalse:
+//					outputFormatter.PrintText("IsFalse");
+//					break;
+//				case OverloadableOperatorType.Like:
+//					op = Tokens.Like;
+//					break;
+//				case OverloadableOperatorType.Power:
+//					op = Tokens.Power;
+//					break;
+//				case OverloadableOperatorType.CType:
+//					op = Tokens.CType;
+//					break;
+//				case OverloadableOperatorType.DivideInteger:
+//					op = Tokens.DivInteger;
+//					break;
+//			}
+//			
+//			
+//			
+//			if (operatorDeclaration.IsConversionOperator) {
+//				outputFormatter.PrintToken(Tokens.CType);
+//			} else {
+//				if(op != -1)  outputFormatter.PrintToken(op);
+//			}
+//			
+//			PrintTemplates(operatorDeclaration.Templates);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(operatorDeclaration.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			if (!operatorDeclaration.TypeReference.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				VisitReturnTypeAttributes(operatorDeclaration.Attributes, data);
+//				TrackedVisit(operatorDeclaration.TypeReference, data);
+//			}
+//			
+//			outputFormatter.NewLine();
+//			
+//			++outputFormatter.IndentationLevel;
+//			TrackedVisit(operatorDeclaration.Body, data);
+//			--outputFormatter.IndentationLevel;
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Operator);
+//			outputFormatter.NewLine();
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data)
+//		{
+//			VisitAttributes(declareDeclaration.Attributes, data);
+//			outputFormatter.Indent();
+//			OutputModifier(declareDeclaration.Modifier);
+//			outputFormatter.PrintToken(Tokens.Declare);
+//			outputFormatter.Space();
+//			
+//			switch (declareDeclaration.Charset) {
+//				case CharsetModifier.Auto:
+//					outputFormatter.PrintToken(Tokens.Auto);
+//					outputFormatter.Space();
+//					break;
+//				case CharsetModifier.Unicode:
+//					outputFormatter.PrintToken(Tokens.Unicode);
+//					outputFormatter.Space();
+//					break;
+//				case CharsetModifier.Ansi:
+//					outputFormatter.PrintToken(Tokens.Ansi);
+//					outputFormatter.Space();
+//					break;
+//			}
+//			
+//			bool isVoid = declareDeclaration.TypeReference.IsNull || declareDeclaration.TypeReference.Type == "System.Void";
+//			if (isVoid) {
+//				outputFormatter.PrintToken(Tokens.Sub);
+//			} else {
+//				outputFormatter.PrintToken(Tokens.Function);
+//			}
+//			outputFormatter.Space();
+//			
+//			outputFormatter.PrintIdentifier(declareDeclaration.Name);
+//			
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Lib);
+//			outputFormatter.Space();
+//			outputFormatter.PrintText(ConvertString(declareDeclaration.Library));
+//			outputFormatter.Space();
+//			
+//			if (declareDeclaration.Alias.Length > 0) {
+//				outputFormatter.PrintToken(Tokens.Alias);
+//				outputFormatter.Space();
+//				outputFormatter.PrintText(ConvertString(declareDeclaration.Alias));
+//				outputFormatter.Space();
+//			}
+//			
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(declareDeclaration.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			if (!isVoid) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				VisitReturnTypeAttributes(declareDeclaration.Attributes, data);
+//				TrackedVisit(declareDeclaration.TypeReference, data);
+//			}
+//			
+//			outputFormatter.NewLine();
+//			
+//			return null;
+//		}
+//		#endregion
+//		
+//		#region Statements
+//		public override object TrackedVisitBlockStatement(BlockStatement blockStatement, object data)
+//		{
+//			if (blockStatement.Parent is BlockStatement) {
+//				outputFormatter.Indent();
+//				outputFormatter.PrintText("If True Then");
+//				outputFormatter.NewLine();
+//				outputFormatter.IndentationLevel += 1;
+//			}
+//			VisitStatementList(blockStatement.Children);
+//			if (blockStatement.Parent is BlockStatement) {
+//				outputFormatter.IndentationLevel -= 1;
+//				outputFormatter.Indent();
+//				outputFormatter.PrintText("End If");
+//				outputFormatter.NewLine();
+//			}
+//			return null;
+//		}
+//		
+//		void PrintIndentedBlock(Statement stmt)
+//		{
+//			outputFormatter.IndentationLevel += 1;
+//			if (stmt is BlockStatement) {
+//				TrackedVisit(stmt, null);
+//			} else {
+//				outputFormatter.Indent();
+//				TrackedVisit(stmt, null);
+//				outputFormatter.NewLine();
+//			}
+//			outputFormatter.IndentationLevel -= 1;
+//		}
+//		
+//		void PrintIndentedBlock(IEnumerable statements)
+//		{
+//			outputFormatter.IndentationLevel += 1;
+//			VisitStatementList(statements);
+//			outputFormatter.IndentationLevel -= 1;
+//		}
+//		
+//		void VisitStatementList(IEnumerable statements)
+//		{
+//			foreach (Statement stmt in statements) {
+//				if (stmt is BlockStatement) {
+//					TrackedVisit(stmt, null);
+//				} else {
+//					outputFormatter.Indent();
+//					TrackedVisit(stmt, null);
+//					outputFormatter.NewLine();
+//				}
+//			}
+//		}
+//		
+//		public override object TrackedVisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.AddHandler);
+//			outputFormatter.Space();
+//			TrackedVisit(addHandlerStatement.EventExpression, data);
+//			outputFormatter.PrintToken(Tokens.Comma);
+//			outputFormatter.Space();
+//			TrackedVisit(addHandlerStatement.HandlerExpression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.RemoveHandler);
+//			outputFormatter.Space();
+//			TrackedVisit(removeHandlerStatement.EventExpression, data);
+//			outputFormatter.PrintToken(Tokens.Comma);
+//			outputFormatter.Space();
+//			TrackedVisit(removeHandlerStatement.HandlerExpression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.RaiseEvent);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(raiseEventStatement.EventName);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(raiseEventStatement.Arguments);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitEraseStatement(EraseStatement eraseStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Erase);
+//			outputFormatter.Space();
+//			AppendCommaSeparatedList(eraseStatement.Expressions);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitErrorStatement(ErrorStatement errorStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Error);
+//			outputFormatter.Space();
+//			TrackedVisit(errorStatement.Expression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitOnErrorStatement(OnErrorStatement onErrorStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.On);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Error);
+//			outputFormatter.Space();
+//			TrackedVisit(onErrorStatement.EmbeddedStatement, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitReDimStatement(ReDimStatement reDimStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.ReDim);
+//			outputFormatter.Space();
+//			if (reDimStatement.IsPreserve) {
+//				outputFormatter.PrintToken(Tokens.Preserve);
+//				outputFormatter.Space();
+//			}
+//			
+//			AppendCommaSeparatedList(reDimStatement.ReDimClauses);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitExpressionStatement(ExpressionStatement expressionStatement, object data)
+//		{
+//			TrackedVisit(expressionStatement.Expression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
+//		{
+//			if (localVariableDeclaration.Modifier != Modifiers.None) {
+//				OutputModifier(localVariableDeclaration.Modifier & ~Modifiers.Dim);
+//			}
+//			if (!isUsingResourceAcquisition) {
+//				if ((localVariableDeclaration.Modifier & Modifiers.Const) == 0) {
+//					outputFormatter.PrintToken(Tokens.Dim);
+//				}
+//				outputFormatter.Space();
+//			}
+//			currentVariableType = localVariableDeclaration.TypeReference;
+//			
+//			AppendCommaSeparatedList(localVariableDeclaration.Variables);
+//			currentVariableType = null;
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitReturnStatement(ReturnStatement returnStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Return);
+//			if (!returnStatement.Expression.IsNull) {
+//				outputFormatter.Space();
+//				TrackedVisit(returnStatement.Expression, data);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitIfElseStatement(IfElseStatement ifElseStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.If);
+//			outputFormatter.Space();
+//			TrackedVisit(ifElseStatement.Condition, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Then);
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(ifElseStatement.TrueStatement);
+//			
+//			foreach (ElseIfSection elseIfSection in ifElseStatement.ElseIfSections) {
+//				TrackedVisit(elseIfSection, data);
+//			}
+//			
+//			if (ifElseStatement.HasElseStatements) {
+//				outputFormatter.Indent();
+//				outputFormatter.PrintToken(Tokens.Else);
+//				outputFormatter.NewLine();
+//				PrintIndentedBlock(ifElseStatement.FalseStatement);
+//			}
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.If);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitElseIfSection(ElseIfSection elseIfSection, object data)
+//		{
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.ElseIf);
+//			outputFormatter.Space();
+//			TrackedVisit(elseIfSection.Condition, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Then);
+//			outputFormatter.NewLine();
+//			PrintIndentedBlock(elseIfSection.EmbeddedStatement);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitLabelStatement(LabelStatement labelStatement, object data)
+//		{
+//			outputFormatter.PrintIdentifier(labelStatement.Label);
+//			outputFormatter.PrintToken(Tokens.Colon);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitGotoStatement(GotoStatement gotoStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.GoTo);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(gotoStatement.Label);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitSwitchStatement(SwitchStatement switchStatement, object data)
+//		{
+//			exitTokenStack.Push(Tokens.Select);
+//			outputFormatter.PrintToken(Tokens.Select);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Case);
+//			outputFormatter.Space();
+//			TrackedVisit(switchStatement.SwitchExpression, data);
+//			outputFormatter.NewLine();
+//			++outputFormatter.IndentationLevel;
+//			foreach (SwitchSection section in switchStatement.SwitchSections) {
+//				TrackedVisit(section, data);
+//			}
+//			--outputFormatter.IndentationLevel;
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Select);
+//			exitTokenStack.Pop();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitSwitchSection(SwitchSection switchSection, object data)
+//		{
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.Case);
+//			outputFormatter.Space();
+//			this.AppendCommaSeparatedList(switchSection.SwitchLabels);
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(switchSection.Children);
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitCaseLabel(CaseLabel caseLabel, object data)
+//		{
+//			if (caseLabel.IsDefault) {
+//				outputFormatter.PrintToken(Tokens.Else);
+//			} else {
+//				if (caseLabel.BinaryOperatorType != BinaryOperatorType.None) {
+//					switch (caseLabel.BinaryOperatorType) {
+//						case BinaryOperatorType.Equality:
+//							outputFormatter.PrintToken(Tokens.Assign);
+//							break;
+//						case BinaryOperatorType.InEquality:
+//							outputFormatter.PrintToken(Tokens.LessThan);
+//							outputFormatter.PrintToken(Tokens.GreaterThan);
+//							break;
+//							
+//						case BinaryOperatorType.GreaterThan:
+//							outputFormatter.PrintToken(Tokens.GreaterThan);
+//							break;
+//						case BinaryOperatorType.GreaterThanOrEqual:
+//							outputFormatter.PrintToken(Tokens.GreaterEqual);
+//							break;
+//						case BinaryOperatorType.LessThan:
+//							outputFormatter.PrintToken(Tokens.LessThan);
+//							break;
+//						case BinaryOperatorType.LessThanOrEqual:
+//							outputFormatter.PrintToken(Tokens.LessEqual);
+//							break;
+//					}
+//					outputFormatter.Space();
+//				}
+//				
+//				TrackedVisit(caseLabel.Label, data);
+//				if (!caseLabel.ToExpression.IsNull) {
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.To);
+//					outputFormatter.Space();
+//					TrackedVisit(caseLabel.ToExpression, data);
+//				}
+//			}
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitStopStatement(StopStatement stopStatement, object data)
 //		{
+//			outputFormatter.PrintToken(Tokens.Stop);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitResumeStatement(ResumeStatement resumeStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Resume);
+//			outputFormatter.Space();
+//			if (resumeStatement.IsResumeNext) {
+//				outputFormatter.PrintToken(Tokens.Next);
+//			} else {
+//				outputFormatter.PrintIdentifier(resumeStatement.LabelName);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitEndStatement(EndStatement endStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.End);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitContinueStatement(ContinueStatement continueStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Continue);
+//			outputFormatter.Space();
+//			switch (continueStatement.ContinueType) {
+//				case ContinueType.Do:
+//					outputFormatter.PrintToken(Tokens.Do);
+//					break;
+//				case ContinueType.For:
+//					outputFormatter.PrintToken(Tokens.For);
+//					break;
+//				case ContinueType.While:
+//					outputFormatter.PrintToken(Tokens.While);
+//					break;
+//				default:
+//					outputFormatter.PrintToken(exitTokenStack.Peek());
+//					break;
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitDoLoopStatement(DoLoopStatement doLoopStatement, object data)
+//		{
+//			if (doLoopStatement.ConditionPosition == ConditionPosition.None) {
+//				Error(String.Format("Unknown condition position for loop : {0}.", doLoopStatement), doLoopStatement.StartLocation);
+//			}
+//			
+//			if (doLoopStatement.ConditionPosition == ConditionPosition.Start) {
+//				switch (doLoopStatement.ConditionType) {
+//					case ConditionType.DoWhile:
+//						exitTokenStack.Push(Tokens.Do);
+//						outputFormatter.PrintToken(Tokens.Do);
+//						outputFormatter.Space();
+//						outputFormatter.PrintToken(Tokens.While);
+//						break;
+//					case ConditionType.While:
+//						exitTokenStack.Push(Tokens.While);
+//						outputFormatter.PrintToken(Tokens.While);
+//						break;
+//					case ConditionType.Until:
+//						exitTokenStack.Push(Tokens.Do);
+//						outputFormatter.PrintToken(Tokens.Do);
+//						outputFormatter.Space();
+//						outputFormatter.PrintToken(Tokens.While);
+//						break;
+//					default:
+//						throw new InvalidOperationException();
+//				}
+//				outputFormatter.Space();
+//				TrackedVisit(doLoopStatement.Condition, null);
+//			} else {
+//				exitTokenStack.Push(Tokens.Do);
+//				outputFormatter.PrintToken(Tokens.Do);
+//			}
+//			
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(doLoopStatement.EmbeddedStatement);
+//			
+//			outputFormatter.Indent();
+//			if (doLoopStatement.ConditionPosition == ConditionPosition.Start && doLoopStatement.ConditionType == ConditionType.While) {
+//				outputFormatter.PrintToken(Tokens.End);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.While);
+//			} else {
+//				outputFormatter.PrintToken(Tokens.Loop);
+//			}
+//			
+//			if (doLoopStatement.ConditionPosition == ConditionPosition.End && !doLoopStatement.Condition.IsNull) {
+//				outputFormatter.Space();
+//				switch (doLoopStatement.ConditionType) {
+//					case ConditionType.While:
+//					case ConditionType.DoWhile:
+//						outputFormatter.PrintToken(Tokens.While);
+//						break;
+//					case ConditionType.Until:
+//						outputFormatter.PrintToken(Tokens.Until);
+//						break;
+//				}
+//				outputFormatter.Space();
+//				TrackedVisit(doLoopStatement.Condition, null);
+//			}
+//			exitTokenStack.Pop();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitForeachStatement(ForeachStatement foreachStatement, object data)
+//		{
+//			exitTokenStack.Push(Tokens.For);
+//			outputFormatter.PrintToken(Tokens.For);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Each);
+//			outputFormatter.Space();
+//			
+//			// loop control variable
+//			outputFormatter.PrintIdentifier(foreachStatement.VariableName);
+//			if (!foreachStatement.TypeReference.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				TrackedVisit(foreachStatement.TypeReference, data);
+//			}
+//			
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.In);
+//			outputFormatter.Space();
+//			
+//			TrackedVisit(foreachStatement.Expression, data);
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(foreachStatement.EmbeddedStatement);
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.Next);
+//			if (!foreachStatement.NextExpression.IsNull) {
+//				outputFormatter.Space();
+//				TrackedVisit(foreachStatement.NextExpression, data);
+//			}
+//			exitTokenStack.Pop();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitLockStatement(LockStatement lockStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.SyncLock);
+//			outputFormatter.Space();
+//			TrackedVisit(lockStatement.LockExpression, data);
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(lockStatement.EmbeddedStatement);
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.SyncLock);
+//			return null;
+//		}
+//		
+//		bool isUsingResourceAcquisition;
+//		
+//		public override object TrackedVisitUsingStatement(UsingStatement usingStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Using);
+//			outputFormatter.Space();
+//			
+//			isUsingResourceAcquisition = true;
+//			TrackedVisit(usingStatement.ResourceAcquisition, data);
+//			isUsingResourceAcquisition = false;
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(usingStatement.EmbeddedStatement);
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Using);
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitWithStatement(WithStatement withStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.With);
+//			outputFormatter.Space();
+//			TrackedVisit(withStatement.Expression, data);
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(withStatement.Body);
+//			
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.With);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
+//		{
+//			exitTokenStack.Push(Tokens.Try);
+//			outputFormatter.PrintToken(Tokens.Try);
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(tryCatchStatement.StatementBlock);
+//			
+//			foreach (CatchClause catchClause in tryCatchStatement.CatchClauses) {
+//				TrackedVisit(catchClause, data);
+//			}
+//			
+//			if (!tryCatchStatement.FinallyBlock.IsNull) {
+//				outputFormatter.Indent();
+//				outputFormatter.PrintToken(Tokens.Finally);
+//				outputFormatter.NewLine();
+//				PrintIndentedBlock(tryCatchStatement.FinallyBlock);
+//			}
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.End);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Try);
+//			exitTokenStack.Pop();
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitCatchClause(CatchClause catchClause, object data)
+//		{
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.Catch);
+//			
+//			if (!catchClause.TypeReference.IsNull) {
+//				outputFormatter.Space();
+//				if (catchClause.VariableName.Length > 0) {
+//					outputFormatter.PrintIdentifier(catchClause.VariableName);
+//				} else {
+//					outputFormatter.PrintIdentifier("generatedExceptionName");
+//				}
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.As);
+//				outputFormatter.Space();
+//				outputFormatter.PrintIdentifier(catchClause.TypeReference.Type);
+//			}
+//			
+//			if (!catchClause.Condition.IsNull)  {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.When);
+//				outputFormatter.Space();
+//				TrackedVisit(catchClause.Condition, data);
+//			}
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(catchClause.StatementBlock);
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitThrowStatement(ThrowStatement throwStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Throw);
+//			if (!throwStatement.Expression.IsNull) {
+//				outputFormatter.Space();
+//				TrackedVisit(throwStatement.Expression, data);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitExitStatement(ExitStatement exitStatement, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Exit);
+//			if (exitStatement.ExitType != ExitType.None) {
+//				outputFormatter.Space();
+//				switch (exitStatement.ExitType) {
+//					case ExitType.Sub:
+//						outputFormatter.PrintToken(Tokens.Sub);
+//						break;
+//					case ExitType.Function:
+//						outputFormatter.PrintToken(Tokens.Function);
+//						break;
+//					case ExitType.Property:
+//						outputFormatter.PrintToken(Tokens.Property);
+//						break;
+//					case ExitType.Do:
+//						outputFormatter.PrintToken(Tokens.Do);
+//						break;
+//					case ExitType.For:
+//						outputFormatter.PrintToken(Tokens.For);
+//						break;
+//					case ExitType.Try:
+//						outputFormatter.PrintToken(Tokens.Try);
+//						break;
+//					case ExitType.While:
+//						outputFormatter.PrintToken(Tokens.While);
+//						break;
+//					case ExitType.Select:
+//						outputFormatter.PrintToken(Tokens.Select);
+//						break;
+//					default:
+//						Error(String.Format("Unsupported exit type : {0}", exitStatement.ExitType), exitStatement.StartLocation);
+//						break;
+//				}
+//			}
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitForNextStatement(ForNextStatement forNextStatement, object data)
+//		{
+//			exitTokenStack.Push(Tokens.For);
+//			outputFormatter.PrintToken(Tokens.For);
+//			outputFormatter.Space();
+//			
+//			if (!forNextStatement.LoopVariableExpression.IsNull) {
+//				TrackedVisit(forNextStatement.LoopVariableExpression, data);
+//			} else {
+//				outputFormatter.PrintIdentifier(forNextStatement.VariableName);
+//				
+//				if (!forNextStatement.TypeReference.IsNull) {
+//					outputFormatter.Space();
+//					outputFormatter.PrintToken(Tokens.As);
+//					outputFormatter.Space();
+//					TrackedVisit(forNextStatement.TypeReference, data);
+//				}
+//			}
+//			
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Assign);
+//			outputFormatter.Space();
+//			
+//			TrackedVisit(forNextStatement.Start, data);
+//			
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.To);
+//			outputFormatter.Space();
+//			
+//			TrackedVisit(forNextStatement.End, data);
+//			
+//			if (!forNextStatement.Step.IsNull) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Step);
+//				outputFormatter.Space();
+//				TrackedVisit(forNextStatement.Step, data);
+//			}
+//			outputFormatter.NewLine();
+//			
+//			PrintIndentedBlock(forNextStatement.EmbeddedStatement);
+//			
+//			outputFormatter.Indent();
+//			outputFormatter.PrintToken(Tokens.Next);
+//			
+//			if (forNextStatement.NextExpressions.Count > 0) {
+//				outputFormatter.Space();
+//				AppendCommaSeparatedList(forNextStatement.NextExpressions);
+//			}
+//			exitTokenStack.Pop();
+//			return null;
+//		}
+//		#endregion
+//		
+//		#region Expressions
+//		
+//		public override object TrackedVisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.MyClass);
+//			return null;
+//		}
+//		
+//		
+//		static string ConvertCharLiteral(char ch)
+//		{
+//			if (Char.IsControl(ch)) {
+//				string charName = GetCharName(ch);
+//				if (charName != null)
+//					return "ControlChars." + charName;
+//				else
+//					return "ChrW(" + ((int)ch).ToString() + ")";
+//			} else if (ch == '"') {
+//				return "\"\"\"\"C";
+//			} else {
+//				return "\"" + ch.ToString() + "\"C";
+//			}
+//		}
+//		
+//		static string GetCharName(char ch)
+//		{
+//			switch (ch) {
+//				case '\b':
+//					return "Back";
+//				case '\r':
+//					return "Cr";
+//				case '\f':
+//					return "FormFeed";
+//				case '\n':
+//					return "Lf";
+//				case '\0':
+//					return "NullChar";
+//				case '\t':
+//					return "Tab";
+//				case '\v':
+//					return "VerticalTab";
+//				default:
+//					return null;
+//			}
+//		}
+//		
+//		static string ConvertString(string str)
+//		{
+//			StringBuilder sb = new StringBuilder();
+//			bool inString = false;
+//			foreach (char ch in str) {
+//				if (char.IsControl(ch)) {
+//					if (inString) {
+//						sb.Append('"');
+//						inString = false;
+//					}
+//					if (sb.Length > 0)
+//						sb.Append(" & ");
+//					string charName = GetCharName(ch);
+//					if (charName != null)
+//						sb.Append("vb" + charName);
+//					else
+//						sb.Append("ChrW(" + ((int)ch) + ")");
+//				} else {
+//					if (!inString) {
+//						if (sb.Length > 0)
+//							sb.Append(" & ");
+//						sb.Append('"');
+//						inString = true;
+//					}
+//					if (ch == '"') {
+//						sb.Append("\"\"");
+//					} else {
+//						sb.Append(ch);
+//					}
+//				}
+//			}
+//			if (inString)
+//				sb.Append('"');
+//			if (sb.Length == 0)
+//				return "\"\"";
+//			return sb.ToString();
+//		}
+//		
+//		public override object TrackedVisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
+//		{
+//			outputFormatter.PrintText(ToVBNetString(primitiveExpression));
+//			return null;
+//		}
+//		
+//		internal static string ToVBNetString(PrimitiveExpression primitiveExpression)
+//		{
+//			object val = primitiveExpression.Value;
+//			if (val == null) {
+//				return "Nothing";
+//			}
+//			if (val is bool) {
+//				if ((bool)primitiveExpression.Value) {
+//					return "True";
+//				} else {
+//					return "False";
+//				}
+//			}
+//			
+//			if (val is string) {
+//				return ConvertString((string)val);
+//			}
+//			
+//			if (val is char) {
+//				return ConvertCharLiteral((char)primitiveExpression.Value);
+//			}
+//
+//			if (val is decimal) {
+//				return ((decimal)primitiveExpression.Value).ToString(NumberFormatInfo.InvariantInfo) + "D";
+//			}
+//			
+//			if (val is float) {
+//				return ((float)primitiveExpression.Value).ToString(NumberFormatInfo.InvariantInfo) + "F";
+//			}
+//			
+//			if (val is double) {
+//				string text = ((double)val).ToString(NumberFormatInfo.InvariantInfo);
+//				if (text.IndexOf('.') < 0 && text.IndexOf('E') < 0)
+//					return text + ".0";
+//				else
+//					return text;
+//			}
+//			
+//			if (val is IFormattable) {
+//				StringBuilder b = new StringBuilder();
+//				if (primitiveExpression.LiteralFormat == LiteralFormat.HexadecimalNumber) {
+//					b.Append("&H");
+//					b.Append(((IFormattable)val).ToString("x", NumberFormatInfo.InvariantInfo));
+//				} else {
+//					b.Append(((IFormattable)val).ToString(null, NumberFormatInfo.InvariantInfo));
+//				}
+//				if (val is ushort || val is uint || val is ulong) {
+//					b.Append('U');
+//					if (val is uint)
+//						b.Append('I');
+//				}
+//				if (val is long || val is ulong)
+//					b.Append('L');
+//				if (val is short || val is ushort)
+//					b.Append('S');
+//				return b.ToString();
+//			} else {
+//				return val.ToString();
+//			}
+//		}
+//		
+//		public override object TrackedVisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
+//		{
+//			int  op = 0;
+//			switch (binaryOperatorExpression.Op) {
+//				case BinaryOperatorType.Concat:
+//					op = Tokens.ConcatString;
+//					break;
+//					
+//				case BinaryOperatorType.Add:
+//					op = Tokens.Plus;
+//					break;
+//					
+//				case BinaryOperatorType.Subtract:
+//					op = Tokens.Minus;
+//					break;
+//					
+//				case BinaryOperatorType.Multiply:
+//					op = Tokens.Times;
+//					break;
+//					
+//				case BinaryOperatorType.Divide:
+//					op = Tokens.Div;
+//					break;
+//					
+//				case BinaryOperatorType.DivideInteger:
+//					op = Tokens.DivInteger;
+//					break;
+//					
+//				case BinaryOperatorType.Modulus:
+//					op = Tokens.Mod;
+//					break;
+//					
+//				case BinaryOperatorType.ShiftLeft:
+//					op = Tokens.ShiftLeft;
+//					break;
+//					
+//				case BinaryOperatorType.ShiftRight:
+//					op = Tokens.ShiftRight;
+//					break;
+//					
+//				case BinaryOperatorType.BitwiseAnd:
+//					op = Tokens.And;
+//					break;
+//				case BinaryOperatorType.BitwiseOr:
+//					op = Tokens.Or;
+//					break;
+//				case BinaryOperatorType.ExclusiveOr:
+//					op = Tokens.Xor;
+//					break;
+//					
+//				case BinaryOperatorType.LogicalAnd:
+//					op = Tokens.AndAlso;
+//					break;
+//				case BinaryOperatorType.LogicalOr:
+//					op = Tokens.OrElse;
+//					break;
+//				case BinaryOperatorType.ReferenceEquality:
+//					op = Tokens.Is;
+//					break;
+//				case BinaryOperatorType.ReferenceInequality:
+//					op = Tokens.IsNot;
+//					break;
+//					
+//				case BinaryOperatorType.Equality:
+//					op = Tokens.Assign;
+//					break;
+//				case BinaryOperatorType.GreaterThan:
+//					op = Tokens.GreaterThan;
+//					break;
+//				case BinaryOperatorType.GreaterThanOrEqual:
+//					op = Tokens.GreaterEqual;
+//					break;
+//				case BinaryOperatorType.InEquality:
+//					op = Tokens.NotEqual;
+//					break;
+//				case BinaryOperatorType.NullCoalescing:
+//					outputFormatter.PrintText("If(");
+//					TrackedVisit(binaryOperatorExpression.Left, data);
+//					outputFormatter.PrintToken(Tokens.Comma);
+//					outputFormatter.Space();
+//					TrackedVisit(binaryOperatorExpression.Right, data);
+//					outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//					return null;
+//				case BinaryOperatorType.DictionaryAccess:
+//					{
+//						PrimitiveExpression pright = binaryOperatorExpression.Right as PrimitiveExpression;
+//						TrackedVisit(binaryOperatorExpression.Left, data);
+//						if (pright != null && pright.Value is string) {
+//							outputFormatter.PrintText("!" + (string)pright.Value);
+//						} else {
+//							outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//							TrackedVisit(binaryOperatorExpression.Right, data);
+//							outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//						}
+//						return null;
+//					}
+//				case BinaryOperatorType.LessThan:
+//					op = Tokens.LessThan;
+//					break;
+//				case BinaryOperatorType.LessThanOrEqual:
+//					op = Tokens.LessEqual;
+//					break;
+//			}
+//			
+//			
+//			BinaryOperatorExpression childBoe = binaryOperatorExpression.Left as BinaryOperatorExpression;
+//			bool requireParenthesis = childBoe != null && OperatorPrecedence.ComparePrecedenceVB(binaryOperatorExpression.Op, childBoe.Op) > 0;
+//			if (requireParenthesis)
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(binaryOperatorExpression.Left, data);
+//			if (requireParenthesis)
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(op);
+//			outputFormatter.Space();
+//			
+//			childBoe = binaryOperatorExpression.Right as BinaryOperatorExpression;
+//			requireParenthesis = childBoe != null && OperatorPrecedence.ComparePrecedenceVB(binaryOperatorExpression.Op, childBoe.Op) >= 0;
+//			if (requireParenthesis)
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(binaryOperatorExpression.Right, data);
+//			if (requireParenthesis)
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(parenthesizedExpression.Expression, data);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data)
+//		{
+//			TrackedVisit(invocationExpression.TargetObject, data);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(invocationExpression.Arguments);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		void PrintTypeArguments(List<TypeReference> typeArguments)
+//		{
+//			if (typeArguments != null && typeArguments.Count > 0) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				outputFormatter.PrintToken(Tokens.Of);
+//				outputFormatter.Space();
+//				AppendCommaSeparatedList(typeArguments);
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//		}
+//		
+//		public override object TrackedVisitIdentifierExpression(SimpleNameExpression identifierExpression, object data)
+//		{
+//			outputFormatter.PrintIdentifier(identifierExpression.Identifier);
+//			PrintTypeArguments(identifierExpression.TypeArguments);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data)
+//		{
+//			TrackedVisit(typeReferenceExpression.TypeReference, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
+//		{
+//			switch (unaryOperatorExpression.Op) {
+//				case UnaryOperatorType.Not:
+//				case UnaryOperatorType.BitNot:
+//					outputFormatter.PrintToken(Tokens.Not);
+//					outputFormatter.Space();
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					return null;
+//					
+//				case UnaryOperatorType.Decrement:
+//					outputFormatter.PrintText("System.Threading.Interlocked.Decrement(");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText(")");
+//					return null;
+//					
+//				case UnaryOperatorType.Increment:
+//					outputFormatter.PrintText("System.Threading.Interlocked.Increment(");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText(")");
+//					return null;
+//					
+//				case UnaryOperatorType.Minus:
+//					outputFormatter.PrintToken(Tokens.Minus);
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					return null;
+//					
+//				case UnaryOperatorType.Plus:
+//					outputFormatter.PrintToken(Tokens.Plus);
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					return null;
+//					
+//				case UnaryOperatorType.PostDecrement:
+//					outputFormatter.PrintText("System.Math.Max(System.Threading.Interlocked.Decrement(");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText("),");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText(" + 1)");
+//					return null;
+//					
+//				case UnaryOperatorType.PostIncrement:
+//					outputFormatter.PrintText("System.Math.Max(System.Threading.Interlocked.Increment(");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText("),");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText(" - 1)");
+//					return null;
+//					
+//				case UnaryOperatorType.Dereference:
+//					outputFormatter.PrintToken(Tokens.Times);
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					return null;
+//				case UnaryOperatorType.AddressOf:
+//					outputFormatter.PrintToken(Tokens.AddressOf);
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					return null;
+//				default:
+//					Error("unknown unary operator: " + unaryOperatorExpression.Op.ToString(), unaryOperatorExpression.StartLocation);
+//					outputFormatter.PrintText(unaryOperatorExpression.Op.ToString());
+//					outputFormatter.PrintText("(");
+//					TrackedVisit(unaryOperatorExpression.Expression, data);
+//					outputFormatter.PrintText(")");
+//					return null;
+//			}
+//		}
+//		
+//		public override object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
+//		{
+//			int  op = 0;
+//			bool unsupportedOpAssignment = false;
+//			switch (assignmentExpression.Op) {
+//				case AssignmentOperatorType.Assign:
+//					op = Tokens.Assign;
+//					break;
+//				case AssignmentOperatorType.Add:
+//					op = Tokens.PlusAssign;
+//					break;
+//				case AssignmentOperatorType.Subtract:
+//					op = Tokens.MinusAssign;
+//					break;
+//				case AssignmentOperatorType.Multiply:
+//					op = Tokens.TimesAssign;
+//					break;
+//				case AssignmentOperatorType.Divide:
+//					op = Tokens.DivAssign;
+//					break;
+//				case AssignmentOperatorType.ShiftLeft:
+//					op = Tokens.ShiftLeftAssign;
+//					break;
+//				case AssignmentOperatorType.ShiftRight:
+//					op = Tokens.ShiftRightAssign;
+//					break;
+//					
+//				case AssignmentOperatorType.ExclusiveOr:
+//					op = Tokens.Xor;
+//					unsupportedOpAssignment = true;
+//					break;
+//				case AssignmentOperatorType.Modulus:
+//					op = Tokens.Mod;
+//					unsupportedOpAssignment = true;
+//					break;
+//				case AssignmentOperatorType.BitwiseAnd:
+//					op = Tokens.And;
+//					unsupportedOpAssignment = true;
+//					break;
+//				case AssignmentOperatorType.BitwiseOr:
+//					op = Tokens.Or;
+//					unsupportedOpAssignment = true;
+//					break;
+//			}
+//			
+//			TrackedVisit(assignmentExpression.Left, data);
+//			outputFormatter.Space();
+//			
+//			if (unsupportedOpAssignment) { // left = left OP right
+//				outputFormatter.PrintToken(Tokens.Assign);
+//				outputFormatter.Space();
+//				TrackedVisit(assignmentExpression.Left, data);
+//				outputFormatter.Space();
+//			}
+//			
+//			outputFormatter.PrintToken(op);
+//			outputFormatter.Space();
+//			TrackedVisit(assignmentExpression.Right, data);
+//			
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.GetType);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(typeOfExpression.TypeReference, data);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
+//		{
+//			// assigning nothing to a generic type in VB compiles to a DefaultValueExpression
+//			outputFormatter.PrintToken(Tokens.Nothing);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.TypeOf);
+//			outputFormatter.Space();
+//			TrackedVisit(typeOfIsExpression.Expression, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Is);
+//			outputFormatter.Space();
+//			TrackedVisit(typeOfIsExpression.TypeReference, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.AddressOf);
+//			outputFormatter.Space();
+//			TrackedVisit(addressOfExpression.Expression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitCastExpression(CastExpression castExpression, object data)
+//		{
+//			if (castExpression.CastType == CastType.TryCast) {
+//				return PrintCast(Tokens.TryCast, castExpression);
+//			}
+//			if (castExpression.CastType == CastType.Cast || castExpression.CastTo.IsArrayType) {
+//				return PrintCast(Tokens.DirectCast, castExpression);
+//			}
+//			switch (castExpression.CastTo.Type) {
+//				case "System.Boolean":
+//					outputFormatter.PrintToken(Tokens.CBool);
+//					break;
+//				case "System.Byte":
+//					outputFormatter.PrintToken(Tokens.CByte);
+//					break;
+//				case "System.SByte":
+//					outputFormatter.PrintToken(Tokens.CSByte);
+//					break;
+//				case "System.Char":
+//					outputFormatter.PrintToken(Tokens.CChar);
+//					break;
+//				case "System.DateTime":
+//					outputFormatter.PrintToken(Tokens.CDate);
+//					break;
+//				case "System.Decimal":
+//					outputFormatter.PrintToken(Tokens.CDec);
+//					break;
+//				case "System.Double":
+//					outputFormatter.PrintToken(Tokens.CDbl);
+//					break;
+//				case "System.Int16":
+//					outputFormatter.PrintToken(Tokens.CShort);
+//					break;
+//				case "System.Int32":
+//					outputFormatter.PrintToken(Tokens.CInt);
+//					break;
+//				case "System.Int64":
+//					outputFormatter.PrintToken(Tokens.CLng);
+//					break;
+//				case "System.UInt16":
+//					outputFormatter.PrintToken(Tokens.CUShort);
+//					break;
+//				case "System.UInt32":
+//					outputFormatter.PrintToken(Tokens.CUInt);
+//					break;
+//				case "System.UInt64":
+//					outputFormatter.PrintToken(Tokens.CULng);
+//					break;
+//				case "System.Object":
+//					outputFormatter.PrintToken(Tokens.CObj);
+//					break;
+//				case "System.Single":
+//					outputFormatter.PrintToken(Tokens.CSng);
+//					break;
+//				case "System.String":
+//					outputFormatter.PrintToken(Tokens.CStr);
+//					break;
+//				default:
+//					return PrintCast(Tokens.CType, castExpression);
+//			}
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(castExpression.Expression, data);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		object PrintCast(int castToken, CastExpression castExpression)
+//		{
+//			outputFormatter.PrintToken(castToken);
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(castExpression.Expression, null);
+//			outputFormatter.PrintToken(Tokens.Comma);
+//			outputFormatter.Space();
+//			TrackedVisit(castExpression.CastTo, null);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Me);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.MyBase);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.New);
+//			if (!objectCreateExpression.IsAnonymousType) {
+//				outputFormatter.Space();
+//				TrackedVisit(objectCreateExpression.CreateType, data);
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				AppendCommaSeparatedList(objectCreateExpression.Parameters);
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			}
+//			CollectionInitializerExpression initializer = objectCreateExpression.ObjectInitializer;
+//			if (!initializer.IsNull) {
+//				outputFormatter.Space();
+//				if (initializer.CreateExpressions.Any(ce => ce is MemberInitializerExpression))
+//					outputFormatter.PrintToken(Tokens.With);
+//				else
+//					outputFormatter.PrintToken(Tokens.From);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
+//				outputFormatter.IndentationLevel++;
+//				for (int i = 0; i < initializer.CreateExpressions.Count; i++) {
+//					Expression expr = initializer.CreateExpressions[i];
+//					if (i > 0)
+//						outputFormatter.PrintToken(Tokens.Comma);
+//					outputFormatter.PrintLineContinuation();
+//					outputFormatter.Indent();
+//					TrackedVisit(expr, data);
+//				}
+//				outputFormatter.IndentationLevel--;
+//				outputFormatter.PrintLineContinuation();
+//				outputFormatter.Indent();
+//				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.New);
+//			outputFormatter.Space();
+//			PrintTypeReferenceWithoutArray(arrayCreateExpression.CreateType);
+//			
+//			if (arrayCreateExpression.Arguments.Count > 0) {
+//				outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//				AppendCommaSeparatedList(arrayCreateExpression.Arguments);
+//				outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//				PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 1);
+//			} else {
+//				PrintArrayRank(arrayCreateExpression.CreateType.RankSpecifier, 0);
+//			}
+//			
+//			outputFormatter.Space();
+//			
+//			if (arrayCreateExpression.ArrayInitializer.IsNull) {
+//				outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
+//				outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
+//			} else {
+//				TrackedVisit(arrayCreateExpression.ArrayInitializer, data);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression arrayInitializerExpression, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.OpenCurlyBrace);
+//			this.AppendCommaSeparatedList(arrayInitializerExpression.CreateExpressions);
+//			outputFormatter.PrintToken(Tokens.CloseCurlyBrace);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data)
+//		{
+//			if (memberInitializerExpression.IsKey) {
+//				outputFormatter.PrintToken(Tokens.Key);
+//				outputFormatter.Space();
+//			}
+//			outputFormatter.PrintToken(Tokens.Dot);
+//			outputFormatter.PrintIdentifier(memberInitializerExpression.Name);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Assign);
+//			outputFormatter.Space();
+//			TrackedVisit(memberInitializerExpression.Expression, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
+//		{
+//			TrackedVisit(memberReferenceExpression.TargetObject, data);
+//			outputFormatter.PrintToken(Tokens.Dot);
+//			if (string.Equals(memberReferenceExpression.MemberName, "New", StringComparison.OrdinalIgnoreCase)
+//			    && (memberReferenceExpression.TargetObject is BaseReferenceExpression || memberReferenceExpression.TargetObject is ThisReferenceExpression || memberReferenceExpression.TargetObject is ClassReferenceExpression))
+//			{
+//				outputFormatter.PrintToken(Tokens.New);
+//			} else {
+//				outputFormatter.PrintIdentifier(memberReferenceExpression.MemberName);
+//			}
+//			PrintTypeArguments(memberReferenceExpression.TypeArguments);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitDirectionExpression(DirectionExpression directionExpression, object data)
+//		{
+//			// VB does not need to specify the direction in method calls
+//			TrackedVisit(directionExpression.Expression, data);
+//			return null;
+//		}
+//		
+//		
+//		public override object TrackedVisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
+//		{
+//			outputFormatter.PrintText("If");
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			TrackedVisit(conditionalExpression.Condition, data);
+//			outputFormatter.PrintToken(Tokens.Comma);
+//			outputFormatter.Space();
+//			TrackedVisit(conditionalExpression.TrueExpression, data);
+//			outputFormatter.PrintToken(Tokens.Comma);
+//			outputFormatter.Space();
+//			TrackedVisit(conditionalExpression.FalseExpression, data);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			return null;
+//		}
+//		
+//		#endregion
+//		#endregion
+//		
+//		
+//		void OutputModifier(ParameterModifiers modifier)
+//		{
+//			if ((modifier & ParameterModifiers.Optional) == ParameterModifiers.Optional) {
+//				outputFormatter.PrintToken(Tokens.Optional);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & ParameterModifiers.Ref) == ParameterModifiers.Ref
+//			    || (modifier & ParameterModifiers.Out) == ParameterModifiers.Out) {
+//				outputFormatter.PrintToken(Tokens.ByRef);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & ParameterModifiers.Params) == ParameterModifiers.Params) {
+//				outputFormatter.PrintToken(Tokens.ParamArray);
+//				outputFormatter.Space();
+//			}
+//			if (prettyPrintOptions.OutputByValModifier &&
+//			    (modifier & (ParameterModifiers.Params | ParameterModifiers.Ref)) == ParameterModifiers.None)
+//			{
+//				outputFormatter.PrintToken(Tokens.ByVal);
+//				outputFormatter.Space();
+//			}
+//		}
+//		
+//		void OutputModifier(Modifiers modifier)
+//		{
+//			OutputModifier(modifier, false, false);
+//		}
+//		
+//		void OutputModifier(Modifiers modifier, bool forTypeDecl, bool forFieldDecl)
+//		{
+//			if ((modifier & Modifiers.Public) == Modifiers.Public) {
+//				outputFormatter.PrintToken(Tokens.Public);
+//				outputFormatter.Space();
+//			} else if ((modifier & Modifiers.Private) == Modifiers.Private) {
+//				outputFormatter.PrintToken(Tokens.Private);
+//				outputFormatter.Space();
+//			} else if ((modifier & (Modifiers.Protected | Modifiers.Internal)) == (Modifiers.Protected | Modifiers.Internal)) {
+//				outputFormatter.PrintToken(Tokens.Protected);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.Friend);
+//				outputFormatter.Space();
+//			} else if ((modifier & Modifiers.Internal) == Modifiers.Internal) {
+//				outputFormatter.PrintToken(Tokens.Friend);
+//				outputFormatter.Space();
+//			} else if ((modifier & Modifiers.Protected) == Modifiers.Protected) {
+//				outputFormatter.PrintToken(Tokens.Protected);
+//				outputFormatter.Space();
+//			}
+//			
+//			if ((modifier & Modifiers.Static) == Modifiers.Static) {
+//				outputFormatter.PrintToken(Tokens.Shared);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Virtual) == Modifiers.Virtual) {
+//				outputFormatter.PrintToken(Tokens.Overridable);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Abstract) == Modifiers.Abstract) {
+//				if (forFieldDecl)
+//					outputFormatter.PrintToken(Tokens.Dim);
+//				else if (forTypeDecl)
+//					outputFormatter.PrintToken(Tokens.MustInherit);
+//				else
+//					outputFormatter.PrintToken(Tokens.MustOverride);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Dim) == Modifiers.Dim) {
+//				outputFormatter.PrintToken(Tokens.Dim);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Overloads) == Modifiers.Overloads) {
+//				outputFormatter.PrintToken(Tokens.Overloads);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Override) == Modifiers.Override) {
+//				outputFormatter.PrintToken(Tokens.Overrides);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.New) == Modifiers.New) {
+//				outputFormatter.PrintToken(Tokens.Shadows);
+//				outputFormatter.Space();
+//			}
+//			
+//			if ((modifier & Modifiers.Sealed) == Modifiers.Sealed) {
+//				outputFormatter.PrintToken(forTypeDecl ? Tokens.NotInheritable : Tokens.NotOverridable);
+//				outputFormatter.Space();
+//			}
+//			
+//			if ((modifier & Modifiers.ReadOnly) == Modifiers.ReadOnly) {
+//				outputFormatter.PrintToken(Tokens.ReadOnly);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.WriteOnly) == Modifiers.WriteOnly) {
+//				outputFormatter.PrintToken(Tokens.WriteOnly);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Const) == Modifiers.Const) {
+//				outputFormatter.PrintToken(Tokens.Const);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.WithEvents) == Modifiers.WithEvents) {
+//				outputFormatter.PrintToken(Tokens.WithEvents);
+//				outputFormatter.Space();
+//			}
+//			if ((modifier & Modifiers.Partial) == Modifiers.Partial) {
+//				outputFormatter.PrintToken(Tokens.Partial);
+//				outputFormatter.Space();
+//			}
+//			
+//			if ((modifier & Modifiers.Extern) == Modifiers.Extern) {
+//				// not required in VB
+//			}
+//			
+//			if ((modifier & Modifiers.Default) == Modifiers.Default) {
+//				outputFormatter.PrintToken(Tokens.Default);
+//				outputFormatter.Space();
+//			}
+//			
+//			if ((modifier & Modifiers.Volatile) == Modifiers.Volatile) {
+//				Error("'Volatile' modifier not convertable", Location.Empty);
+//			}
+//			
+//			if ((modifier & Modifiers.Unsafe) == Modifiers.Unsafe) {
+//				Error("'Unsafe' modifier not convertable", Location.Empty);
+//			}
+//		}
+//		
+//		public void AppendCommaSeparatedList<T>(ICollection<T> list) where T : class, INode
+//		{
+//			if (list != null) {
+//				int i = 0;
+//				foreach (T node in list) {
+//					TrackedVisit(node, null);
+//					if (i + 1 < list.Count) {
+//						outputFormatter.PrintToken(Tokens.Comma);
+//						outputFormatter.Space();
+//						if ((i + 1) % 6 == 0) {
+//							outputFormatter.PrintLineContinuation();
+//							outputFormatter.Indent();
+//							outputFormatter.PrintText("\t");
+//						}
+//					}
+//					i++;
+//				}
+//			}
+//		}
+//		
+//		void VisitAttributes(ICollection attributes, object data)
+//		{
+//			if (attributes == null) {
+//				return;
+//			}
+//			foreach (AttributeSection section in attributes) {
+//				if (string.Equals(section.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase))
+//					continue;
+//				TrackedVisit(section, data);
+//			}
+//		}
+//		
+//		void VisitReturnTypeAttributes(ICollection attributes, object data)
+//		{
+//			if (attributes == null) {
+//				return;
+//			}
+//			printAttributeSectionInline = true;
+//			foreach (AttributeSection section in attributes) {
+//				if (string.Equals(section.AttributeTarget, "return", StringComparison.OrdinalIgnoreCase)) {
+//					TrackedVisit(section, data);
+//				}
+//			}
+//			printAttributeSectionInline = false;
+//		}
+//		
+//		public override object TrackedVisitLambdaExpression(LambdaExpression lambdaExpression, object data)
+//		{
+//			bool isSub = !lambdaExpression.ReturnType.IsNull &&
+//				lambdaExpression.ReturnType.Type == "System.Void" && lambdaExpression.ReturnType.IsKeyword;
+//			
+//			if (isSub)
+//				outputFormatter.PrintToken(Tokens.Sub);
+//			else
+//				outputFormatter.PrintToken(Tokens.Function);
+//			
+//			outputFormatter.PrintToken(Tokens.OpenParenthesis);
+//			AppendCommaSeparatedList(lambdaExpression.Parameters);
+//			outputFormatter.PrintToken(Tokens.CloseParenthesis);
+//			
+//			outputFormatter.Space();
+//			
+//			if (!lambdaExpression.ExpressionBody.IsNull) {
+//				return lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
+//			} else {
+//				if (!isSub && !lambdaExpression.ReturnType.IsNull) {
+//					outputFormatter.PrintToken(Tokens.As);
+//					outputFormatter.Space();
+//					TrackedVisit(lambdaExpression.ReturnType, data);
+//				}
+//				
+//				if (lambdaExpression.StatementBody is BlockStatement)
+//					outputFormatter.NewLine();
+//				
+//				TrackedVisit(lambdaExpression.StatementBody, data);
+//				
+//				if (lambdaExpression.StatementBody is BlockStatement) {
+//					outputFormatter.NewLine();
+//					outputFormatter.PrintToken(Tokens.End);
+//					outputFormatter.Space();
+//					if (isSub)
+//						outputFormatter.PrintToken(Tokens.Sub);
+//					else
+//						outputFormatter.PrintToken(Tokens.Function);
+//				}
+//				
+//				return null;
+//			}
+//		}
+//		
+//		public override object TrackedVisitQueryExpression(QueryExpression queryExpression, object data)
+//		{
+//			outputFormatter.IndentationLevel++;
+//			for (int i = 0; i < queryExpression.Clauses.Count; i++) {
+//				QueryExpressionClause clause = queryExpression.Clauses[i];
+//				if (!clause.IsNull) {
+//					if (i != 0) {
+//						outputFormatter.PrintLineContinuation();
+//						outputFormatter.Indent();
+//					}
+//					clause.AcceptVisitor(this, null);
+//				}
+//			}
+//			outputFormatter.IndentationLevel--;
+//			return null;
+//		}
+//		
+//		void PrintClause(QueryExpressionClause clause)
+//		{
+//
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionFromClause(QueryExpressionFromClause fromClause, object data)
+//		{
+//			outputFormatter.PrintText("From");
+//			outputFormatter.Space();
+//			for (int i = 0; i < fromClause.Sources.Count; i++) {
+//				CollectionRangeVariable clause = fromClause.Sources[i];
+//				outputFormatter.PrintIdentifier(clause.Identifier);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.In);
+//				outputFormatter.Space();
+//				clause.Expression.AcceptVisitor(this, data);
+//				if (i < fromClause.Sources.Count - 1)
+//					outputFormatter.PrintToken(Tokens.Comma);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionJoinClause(QueryExpressionJoinClause joinClause, object data)
+//		{
+//			outputFormatter.PrintText("Join");
+//			outputFormatter.Space();
+//			CollectionRangeVariable clause = joinClause.Source;
 //			outputFormatter.PrintIdentifier(clause.Identifier);
 //			outputFormatter.Space();
 //			outputFormatter.PrintToken(Tokens.In);
 //			outputFormatter.Space();
-//			clause.InExpression.AcceptVisitor(this, data);
-//		}
-		
-		public override object TrackedVisitQueryExpressionLetClause(QueryExpressionLetClause letClause, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Let);
-			outputFormatter.Space();
-			outputFormatter.PrintIdentifier(letClause.Identifier);
-			outputFormatter.Space();
-			outputFormatter.PrintToken(Tokens.Assign);
-			outputFormatter.Space();
-			return letClause.Expression.AcceptVisitor(this, data);
-		}
-		
-		public override object TrackedVisitQueryExpressionGroupClause(QueryExpressionGroupClause groupClause, object data)
-		{
-			outputFormatter.PrintText("Group");
-			outputFormatter.Space();
-			groupClause.Projection.AcceptVisitor(this, data);
-			outputFormatter.Space();
-			outputFormatter.PrintText("By");
-			outputFormatter.Space();
-			return groupClause.GroupBy.AcceptVisitor(this, data);
-		}
-		
-		public override object TrackedVisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data)
-		{
-			outputFormatter.PrintText("Order By");
-			outputFormatter.Space();
-			AppendCommaSeparatedList(queryExpressionOrderClause.Orderings);
-			return null;
-		}
-		
-		public override object TrackedVisitQueryExpressionOrdering(QueryExpressionOrdering ordering, object data)
-		{
-			ordering.Criteria.AcceptVisitor(this, data);
-			if (ordering.Direction == QueryExpressionOrderingDirection.Ascending) {
-				outputFormatter.Space();
-				outputFormatter.PrintText("Ascending");
-			} else if (ordering.Direction == QueryExpressionOrderingDirection.Descending) {
-				outputFormatter.Space();
-				outputFormatter.PrintText("Descending");
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause selectClause, object data)
-		{
-			outputFormatter.PrintToken(Tokens.Select);
-			outputFormatter.Space();
-			foreach (ExpressionRangeVariable var in selectClause.Variables) {
-				var.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause whereClause, object data)
-		{
-			outputFormatter.Space();
-			outputFormatter.PrintText("Where");
-			outputFormatter.Space();
-			return whereClause.Condition.AcceptVisitor(this, data);
-		}
-		
-		public override object TrackedVisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data)
-		{
-			UnsupportedNode(externAliasDirective);
-			return null;
-		}
-		
-		public override object TrackedVisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data)
-		{
-			switch (xmlContentExpression.Type) {
-				case XmlContentType.Comment:
-					outputFormatter.PrintText("<!--" + xmlContentExpression.Content + "-->");
-					break;
-				case XmlContentType.Text:
-					outputFormatter.PrintText(xmlContentExpression.Content);
-					break;
-				case XmlContentType.CData:
-					outputFormatter.PrintText("<![CDATA[" + xmlContentExpression.Content + "]]>");
-					break;
-				case XmlContentType.ProcessingInstruction:
-					outputFormatter.PrintText("<?" + xmlContentExpression.Content + "?>");
-					break;
-				default:
-					throw new Exception("Invalid value for XmlContentType");
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data)
-		{
-			outputFormatter.PrintText("<%=");
-			outputFormatter.Space();
-			xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
-			outputFormatter.Space();
-			outputFormatter.PrintText("%>");
-			return null;
-		}
-		
-		public override object TrackedVisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data)
-		{
-			outputFormatter.PrintText(xmlAttributeExpression.Name);
-			outputFormatter.PrintToken(Tokens.Assign);
-			if (xmlAttributeExpression.IsLiteralValue) {
-				if (xmlAttributeExpression.UseDoubleQuotes)
-					outputFormatter.PrintText("\"");
-				else
-					outputFormatter.PrintText("'");
-				outputFormatter.PrintText(xmlAttributeExpression.LiteralValue);
-				if (xmlAttributeExpression.UseDoubleQuotes)
-					outputFormatter.PrintText("\"");
-				else
-					outputFormatter.PrintText("'");
-			} else
-				xmlAttributeExpression.ExpressionValue.AcceptVisitor(this, data);
-			return null;
-		}
-		
-		public override object TrackedVisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data)
-		{
-			outputFormatter.PrintText("<");
-			if (xmlElementExpression.NameIsExpression) {
-				outputFormatter.PrintToken(Tokens.XmlStartInlineVB);
-				outputFormatter.Space();
-				xmlElementExpression.NameExpression.AcceptVisitor(this, data);
-				outputFormatter.Space();
-				outputFormatter.PrintToken(Tokens.XmlEndInlineVB);
-			} else {
-				outputFormatter.PrintText(xmlElementExpression.XmlName);
-			}
-			foreach (XmlExpression attribute in xmlElementExpression.Attributes) {
-				outputFormatter.Space();
-				attribute.AcceptVisitor(this, data);
-			}
-			if (xmlElementExpression.Children.Any()) {
-				outputFormatter.PrintText(">");
-				foreach (INode node in xmlElementExpression.Children) {
-					node.AcceptVisitor(this, data);
-				}
-				outputFormatter.PrintText("</");
-				if (!xmlElementExpression.NameIsExpression)
-					outputFormatter.PrintText(xmlElementExpression.XmlName);
-				outputFormatter.PrintText(">");
-			} else {
-				outputFormatter.Space();
-				outputFormatter.PrintText("/>");
-			}
-			return null;
-		}
-		
-		public override object TrackedVisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data)
-		{
-			xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
-			switch (xmlMemberAccessExpression.AxisType) {
-				case XmlAxisType.Element:
-					outputFormatter.PrintToken(Tokens.Dot);
-					break;
-				case XmlAxisType.Attribute:
-					outputFormatter.PrintToken(Tokens.DotAt);
-					break;
-				case XmlAxisType.Descendents:
-					outputFormatter.PrintToken(Tokens.TripleDot);
-					break;
-				default:
-					throw new Exception("Invalid value for XmlAxisType");
-			}
-			if (xmlMemberAccessExpression.IsXmlIdentifier)
-				outputFormatter.PrintText("<" + xmlMemberAccessExpression.Identifier + ">");
-			else
-				outputFormatter.PrintIdentifier(xmlMemberAccessExpression.Identifier);
-			return null;
-		}
-	}
+//			clause.Expression.AcceptVisitor(this, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.On);
+//			outputFormatter.Space();
+//			joinClause.OnExpression.AcceptVisitor(this, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Assign);
+//			outputFormatter.Space();
+//			joinClause.EqualsExpression.AcceptVisitor(this, data);
+//			if (!string.IsNullOrEmpty(joinClause.IntoIdentifier)) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintText("Into");
+//				outputFormatter.Space();
+//				outputFormatter.PrintIdentifier(joinClause.IntoIdentifier);
+//			}
+//			return null;
+//		}
+//		
+////		void VisitQueryExpressionFromOrJoinClause(QueryExpressionFromOrJoinClause clause, object data)
+////		{
+////			outputFormatter.PrintIdentifier(clause.Identifier);
+////			outputFormatter.Space();
+////			outputFormatter.PrintToken(Tokens.In);
+////			outputFormatter.Space();
+////			clause.InExpression.AcceptVisitor(this, data);
+////		}
+//		
+//		public override object TrackedVisitQueryExpressionLetClause(QueryExpressionLetClause letClause, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Let);
+//			outputFormatter.Space();
+//			outputFormatter.PrintIdentifier(letClause.Identifier);
+//			outputFormatter.Space();
+//			outputFormatter.PrintToken(Tokens.Assign);
+//			outputFormatter.Space();
+//			return letClause.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionGroupClause(QueryExpressionGroupClause groupClause, object data)
+//		{
+//			outputFormatter.PrintText("Group");
+//			outputFormatter.Space();
+//			groupClause.Projection.AcceptVisitor(this, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintText("By");
+//			outputFormatter.Space();
+//			return groupClause.GroupBy.AcceptVisitor(this, data);
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data)
+//		{
+//			outputFormatter.PrintText("Order By");
+//			outputFormatter.Space();
+//			AppendCommaSeparatedList(queryExpressionOrderClause.Orderings);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionOrdering(QueryExpressionOrdering ordering, object data)
+//		{
+//			ordering.Criteria.AcceptVisitor(this, data);
+//			if (ordering.Direction == QueryExpressionOrderingDirection.Ascending) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintText("Ascending");
+//			} else if (ordering.Direction == QueryExpressionOrderingDirection.Descending) {
+//				outputFormatter.Space();
+//				outputFormatter.PrintText("Descending");
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause selectClause, object data)
+//		{
+//			outputFormatter.PrintToken(Tokens.Select);
+//			outputFormatter.Space();
+//			foreach (ExpressionRangeVariable var in selectClause.Variables) {
+//				var.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause whereClause, object data)
+//		{
+//			outputFormatter.Space();
+//			outputFormatter.PrintText("Where");
+//			outputFormatter.Space();
+//			return whereClause.Condition.AcceptVisitor(this, data);
+//		}
+//		
+//		public override object TrackedVisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data)
+//		{
+//			UnsupportedNode(externAliasDirective);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data)
+//		{
+//			switch (xmlContentExpression.Type) {
+//				case XmlContentType.Comment:
+//					outputFormatter.PrintText("<!--" + xmlContentExpression.Content + "-->");
+//					break;
+//				case XmlContentType.Text:
+//					outputFormatter.PrintText(xmlContentExpression.Content);
+//					break;
+//				case XmlContentType.CData:
+//					outputFormatter.PrintText("<![CDATA[" + xmlContentExpression.Content + "]]>");
+//					break;
+//				case XmlContentType.ProcessingInstruction:
+//					outputFormatter.PrintText("<?" + xmlContentExpression.Content + "?>");
+//					break;
+//				default:
+//					throw new Exception("Invalid value for XmlContentType");
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data)
+//		{
+//			outputFormatter.PrintText("<%=");
+//			outputFormatter.Space();
+//			xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
+//			outputFormatter.Space();
+//			outputFormatter.PrintText("%>");
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data)
+//		{
+//			outputFormatter.PrintText(xmlAttributeExpression.Name);
+//			outputFormatter.PrintToken(Tokens.Assign);
+//			if (xmlAttributeExpression.IsLiteralValue) {
+//				if (xmlAttributeExpression.UseDoubleQuotes)
+//					outputFormatter.PrintText("\"");
+//				else
+//					outputFormatter.PrintText("'");
+//				outputFormatter.PrintText(xmlAttributeExpression.LiteralValue);
+//				if (xmlAttributeExpression.UseDoubleQuotes)
+//					outputFormatter.PrintText("\"");
+//				else
+//					outputFormatter.PrintText("'");
+//			} else
+//				xmlAttributeExpression.ExpressionValue.AcceptVisitor(this, data);
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data)
+//		{
+//			outputFormatter.PrintText("<");
+//			if (xmlElementExpression.NameIsExpression) {
+//				outputFormatter.PrintToken(Tokens.XmlStartInlineVB);
+//				outputFormatter.Space();
+//				xmlElementExpression.NameExpression.AcceptVisitor(this, data);
+//				outputFormatter.Space();
+//				outputFormatter.PrintToken(Tokens.XmlEndInlineVB);
+//			} else {
+//				outputFormatter.PrintText(xmlElementExpression.XmlName);
+//			}
+//			foreach (XmlExpression attribute in xmlElementExpression.Attributes) {
+//				outputFormatter.Space();
+//				attribute.AcceptVisitor(this, data);
+//			}
+//			if (xmlElementExpression.Children.Any()) {
+//				outputFormatter.PrintText(">");
+//				foreach (INode node in xmlElementExpression.Children) {
+//					node.AcceptVisitor(this, data);
+//				}
+//				outputFormatter.PrintText("</");
+//				if (!xmlElementExpression.NameIsExpression)
+//					outputFormatter.PrintText(xmlElementExpression.XmlName);
+//				outputFormatter.PrintText(">");
+//			} else {
+//				outputFormatter.Space();
+//				outputFormatter.PrintText("/>");
+//			}
+//			return null;
+//		}
+//		
+//		public override object TrackedVisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data)
+//		{
+//			xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
+//			switch (xmlMemberAccessExpression.AxisType) {
+//				case XmlAxisType.Element:
+//					outputFormatter.PrintToken(Tokens.Dot);
+//					break;
+//				case XmlAxisType.Attribute:
+//					outputFormatter.PrintToken(Tokens.DotAt);
+//					break;
+//				case XmlAxisType.Descendents:
+//					outputFormatter.PrintToken(Tokens.TripleDot);
+//					break;
+//				default:
+//					throw new Exception("Invalid value for XmlAxisType");
+//			}
+//			if (xmlMemberAccessExpression.IsXmlIdentifier)
+//				outputFormatter.PrintText("<" + xmlMemberAccessExpression.Identifier + ">");
+//			else
+//				outputFormatter.PrintIdentifier(xmlMemberAccessExpression.Identifier);
+//			return null;
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/SnippetParser.cs b/NRefactory/ICSharpCode.NRefactory.VB/SnippetParser.cs
deleted file mode 100644
index 367ce5abf..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/SnippetParser.cs
+++ /dev/null
@@ -1,130 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-
-using ICSharpCode.NRefactory.VB.Ast;
-using ICSharpCode.NRefactory.VB.Parser;
-
-namespace ICSharpCode.NRefactory.VB
-{
-	public enum SnippetType
-	{
-		None,
-		CompilationUnit,
-		Expression,
-		Statements,
-		TypeMembers
-	}
-	
-	/// <summary>
-	/// The snippet parser supports parsing code snippets that are not valid as a full compilation unit.
-	/// </summary>
-	public class SnippetParser
-	{
-		/// <summary>
-		/// Gets the errors of the last call to Parse(). Returns null if parse was not yet called.
-		/// </summary>
-		public Errors Errors { get; private set; }
-		
-		/// <summary>
-		/// Gets the specials of the last call to Parse(). Returns null if parse was not yet called.
-		/// </summary>
-		public List<ISpecial> Specials { get; private set; }
-		
-		/// <summary>
-		/// Gets the snippet type of the last call to Parse(). Returns None if parse was not yet called.
-		/// </summary>
-		public SnippetType SnippetType { get; private set; }
-		
-		/// <summary>
-		/// Parse the code. The result may be a CompilationUnit, an Expression, a list of statements or a list of class
-		/// members.
-		/// </summary>
-		public INode Parse(string code)
-		{
-			VBParser parser = ParserFactory.CreateParser(new StringReader(code));
-			parser.Parse();
-			this.Errors = parser.Errors;
-			this.Specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
-			this.SnippetType = SnippetType.CompilationUnit;
-			INode result = parser.CompilationUnit;
-			
-			if (this.Errors.Count > 0) {
-				parser = ParserFactory.CreateParser(new StringReader(code));
-				Expression expression = parser.ParseExpression();
-				if (expression != null && parser.Errors.Count < this.Errors.Count) {
-					this.Errors = parser.Errors;
-					this.Specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
-					this.SnippetType = SnippetType.Expression;
-					result = expression;
-				}
-			}
-			if (this.Errors.Count > 0) {
-				parser = ParserFactory.CreateParser(new StringReader(code));
-				BlockStatement block = parser.ParseBlock();
-				if (block != null && parser.Errors.Count < this.Errors.Count) {
-					this.Errors = parser.Errors;
-					this.Specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
-					this.SnippetType = SnippetType.Statements;
-					result = block;
-				}
-			}
-			if (this.Errors.Count > 0) {
-				parser = ParserFactory.CreateParser(new StringReader(code));
-				List<INode> members = parser.ParseTypeMembers();
-				if (members != null && members.Count > 0 && parser.Errors.Count < this.Errors.Count) {
-					this.Errors = parser.Errors;
-					this.Specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
-					this.SnippetType = SnippetType.TypeMembers;
-					result = new NodeListNode(members);
-					result.StartLocation = members[0].StartLocation;
-					result.EndLocation = members[members.Count - 1].EndLocation;
-				}
-			}
-			Debug.Assert(result is CompilationUnit || !result.StartLocation.IsEmpty);
-			Debug.Assert(result is CompilationUnit || !result.EndLocation.IsEmpty);
-			return result;
-		}
-		
-		sealed class NodeListNode : INode
-		{
-			List<INode> nodes;
-			
-			public NodeListNode(List<INode> nodes)
-			{
-				this.nodes = nodes;
-			}
-			
-			public INode Parent {
-				get { return null; }
-				set { throw new NotSupportedException(); }
-			}
-			
-			public List<INode> Children {
-				get { return nodes; }
-			}
-			
-			public Location StartLocation { get; set; }
-			public Location EndLocation { get; set; }
-			
-			public object UserData { get; set; }
-			
-			public object AcceptChildren(IAstVisitor visitor, object data)
-			{
-				foreach (INode n in nodes) {
-					n.AcceptVisitor(visitor, data);
-				}
-				return null;
-			}
-			
-			public object AcceptVisitor(IAstVisitor visitor, object data)
-			{
-				return AcceptChildren(visitor, data);
-			}
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/VBParser.cs b/NRefactory/ICSharpCode.NRefactory.VB/VBParser.cs
new file mode 100644
index 000000000..27d244be1
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory.VB/VBParser.cs
@@ -0,0 +1,55 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+
+using ICSharpCode.NRefactory.VB.Ast;
+using ICSharpCode.NRefactory.VB.Parser;
+
+namespace ICSharpCode.NRefactory.VB
+{
+	public enum SnippetType
+	{
+		None,
+		CompilationUnit,
+		Expression,
+		Statements,
+		TypeMembers
+	}
+	
+	public class VBParser
+	{
+		bool hasErrors;
+		Errors errors;
+		
+		public CompilationUnit Parse(string content)
+		{
+			return Parse(new StringReader(content));
+		}
+		
+		public CompilationUnit Parse(TextReader reader)
+		{
+			var parser = new ICSharpCode.NRefactory.VB.Parser.VBParser(new VBLexer(reader));
+			parser.Parse();
+			hasErrors = parser.Errors.Count > 0;
+			errors = parser.Errors;
+			return parser.CompilationUnit;
+		}
+		
+		public AstNode ParseSnippet(TextReader reader)
+		{
+			throw new NotImplementedException();
+		}
+		
+		public bool HasErrors {
+			get { return hasErrors; }
+		}
+		
+		public Errors Errors {
+			get { return errors; }
+		}
+	}
+}
\ No newline at end of file
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs
index 350626e69..544157506 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstTransformer.cs
@@ -24,2064 +24,2055 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	/// You can use the methods ReplaceCurrentNode and RemoveCurrentNode to replace
 	/// or remove the current node, totally independent from the type of the parent node.
 	/// </summary>
-	public abstract class AbstractAstTransformer : IAstVisitor {
-		
-		private Stack<INode> nodeStack = new Stack<INode>();
-		
-		public void ReplaceCurrentNode(INode newNode) {
-			nodeStack.Pop();
-			nodeStack.Push(newNode);
-		}
-		
-		public void RemoveCurrentNode() {
-			nodeStack.Pop();
-			nodeStack.Push(null);
-		}
-		
-		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
-			Debug.Assert((addHandlerStatement != null));
-			Debug.Assert((addHandlerStatement.EventExpression != null));
-			Debug.Assert((addHandlerStatement.HandlerExpression != null));
-			nodeStack.Push(addHandlerStatement.EventExpression);
-			addHandlerStatement.EventExpression.AcceptVisitor(this, data);
-			addHandlerStatement.EventExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(addHandlerStatement.HandlerExpression);
-			addHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
-			addHandlerStatement.HandlerExpression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
-			Debug.Assert((addressOfExpression != null));
-			Debug.Assert((addressOfExpression.Expression != null));
-			nodeStack.Push(addressOfExpression.Expression);
-			addressOfExpression.Expression.AcceptVisitor(this, data);
-			addressOfExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
-			Debug.Assert((arrayCreateExpression != null));
-			Debug.Assert((arrayCreateExpression.CreateType != null));
-			Debug.Assert((arrayCreateExpression.Arguments != null));
-			Debug.Assert((arrayCreateExpression.ArrayInitializer != null));
-			nodeStack.Push(arrayCreateExpression.CreateType);
-			arrayCreateExpression.CreateType.AcceptVisitor(this, data);
-			arrayCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop()));
-			for (int i = 0; i < arrayCreateExpression.Arguments.Count; i++) {
-				Expression o = arrayCreateExpression.Arguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					arrayCreateExpression.Arguments.RemoveAt(i--);
-				else
-					arrayCreateExpression.Arguments[i] = o;
-			}
-			nodeStack.Push(arrayCreateExpression.ArrayInitializer);
-			arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
-			arrayCreateExpression.ArrayInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
-			Debug.Assert((assignmentExpression != null));
-			Debug.Assert((assignmentExpression.Left != null));
-			Debug.Assert((assignmentExpression.Right != null));
-			nodeStack.Push(assignmentExpression.Left);
-			assignmentExpression.Left.AcceptVisitor(this, data);
-			assignmentExpression.Left = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(assignmentExpression.Right);
-			assignmentExpression.Right.AcceptVisitor(this, data);
-			assignmentExpression.Right = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
-			Debug.Assert((attribute != null));
-			Debug.Assert((attribute.PositionalArguments != null));
-			Debug.Assert((attribute.NamedArguments != null));
-			for (int i = 0; i < attribute.PositionalArguments.Count; i++) {
-				Expression o = attribute.PositionalArguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					attribute.PositionalArguments.RemoveAt(i--);
-				else
-					attribute.PositionalArguments[i] = o;
-			}
-			for (int i = 0; i < attribute.NamedArguments.Count; i++) {
-				NamedArgumentExpression o = attribute.NamedArguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (NamedArgumentExpression)nodeStack.Pop();
-				if (o == null)
-					attribute.NamedArguments.RemoveAt(i--);
-				else
-					attribute.NamedArguments[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitAttributeSection(AttributeSection attributeSection, object data) {
-			Debug.Assert((attributeSection != null));
-			Debug.Assert((attributeSection.Attributes != null));
-			for (int i = 0; i < attributeSection.Attributes.Count; i++) {
-				ICSharpCode.NRefactory.VB.Ast.Attribute o = attributeSection.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ICSharpCode.NRefactory.VB.Ast.Attribute)nodeStack.Pop();
-				if (o == null)
-					attributeSection.Attributes.RemoveAt(i--);
-				else
-					attributeSection.Attributes[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
-			Debug.Assert((baseReferenceExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
-			Debug.Assert((binaryOperatorExpression != null));
-			Debug.Assert((binaryOperatorExpression.Left != null));
-			Debug.Assert((binaryOperatorExpression.Right != null));
-			nodeStack.Push(binaryOperatorExpression.Left);
-			binaryOperatorExpression.Left.AcceptVisitor(this, data);
-			binaryOperatorExpression.Left = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(binaryOperatorExpression.Right);
-			binaryOperatorExpression.Right.AcceptVisitor(this, data);
-			binaryOperatorExpression.Right = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitBlockStatement(BlockStatement blockStatement, object data) {
-			Debug.Assert((blockStatement != null));
-			for (int i = 0; i < blockStatement.Children.Count; i++) {
-				INode o = blockStatement.Children[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = nodeStack.Pop();
-				if (o == null)
-					blockStatement.Children.RemoveAt(i--);
-				else
-					blockStatement.Children[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitCaseLabel(CaseLabel caseLabel, object data) {
-			Debug.Assert((caseLabel != null));
-			Debug.Assert((caseLabel.Label != null));
-			Debug.Assert((caseLabel.ToExpression != null));
-			nodeStack.Push(caseLabel.Label);
-			caseLabel.Label.AcceptVisitor(this, data);
-			caseLabel.Label = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(caseLabel.ToExpression);
-			caseLabel.ToExpression.AcceptVisitor(this, data);
-			caseLabel.ToExpression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitCastExpression(CastExpression castExpression, object data) {
-			Debug.Assert((castExpression != null));
-			Debug.Assert((castExpression.CastTo != null));
-			Debug.Assert((castExpression.Expression != null));
-			nodeStack.Push(castExpression.CastTo);
-			castExpression.CastTo.AcceptVisitor(this, data);
-			castExpression.CastTo = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(castExpression.Expression);
-			castExpression.Expression.AcceptVisitor(this, data);
-			castExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitCatchClause(CatchClause catchClause, object data) {
-			Debug.Assert((catchClause != null));
-			Debug.Assert((catchClause.TypeReference != null));
-			Debug.Assert((catchClause.StatementBlock != null));
-			Debug.Assert((catchClause.Condition != null));
-			nodeStack.Push(catchClause.TypeReference);
-			catchClause.TypeReference.AcceptVisitor(this, data);
-			catchClause.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(catchClause.StatementBlock);
-			catchClause.StatementBlock.AcceptVisitor(this, data);
-			catchClause.StatementBlock = ((Statement)(nodeStack.Pop()));
-			nodeStack.Push(catchClause.Condition);
-			catchClause.Condition.AcceptVisitor(this, data);
-			catchClause.Condition = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
-			Debug.Assert((classReferenceExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
-			Debug.Assert((collectionInitializerExpression != null));
-			Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
-			for (int i = 0; i < collectionInitializerExpression.CreateExpressions.Count; i++) {
-				Expression o = collectionInitializerExpression.CreateExpressions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					collectionInitializerExpression.CreateExpressions.RemoveAt(i--);
-				else
-					collectionInitializerExpression.CreateExpressions[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
-			Debug.Assert((collectionRangeVariable != null));
-			Debug.Assert((collectionRangeVariable.Expression != null));
-			Debug.Assert((collectionRangeVariable.Type != null));
-			nodeStack.Push(collectionRangeVariable.Expression);
-			collectionRangeVariable.Expression.AcceptVisitor(this, data);
-			collectionRangeVariable.Expression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(collectionRangeVariable.Type);
-			collectionRangeVariable.Type.AcceptVisitor(this, data);
-			collectionRangeVariable.Type = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
-			Debug.Assert((compilationUnit != null));
-			for (int i = 0; i < compilationUnit.Children.Count; i++) {
-				INode o = compilationUnit.Children[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = nodeStack.Pop();
-				if (o == null)
-					compilationUnit.Children.RemoveAt(i--);
-				else
-					compilationUnit.Children[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
-			Debug.Assert((conditionalExpression != null));
-			Debug.Assert((conditionalExpression.Condition != null));
-			Debug.Assert((conditionalExpression.TrueExpression != null));
-			Debug.Assert((conditionalExpression.FalseExpression != null));
-			nodeStack.Push(conditionalExpression.Condition);
-			conditionalExpression.Condition.AcceptVisitor(this, data);
-			conditionalExpression.Condition = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(conditionalExpression.TrueExpression);
-			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
-			conditionalExpression.TrueExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(conditionalExpression.FalseExpression);
-			conditionalExpression.FalseExpression.AcceptVisitor(this, data);
-			conditionalExpression.FalseExpression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
-			Debug.Assert((constructorDeclaration != null));
-			Debug.Assert((constructorDeclaration.Attributes != null));
-			Debug.Assert((constructorDeclaration.Parameters != null));
-			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
-			Debug.Assert((constructorDeclaration.Body != null));
-			for (int i = 0; i < constructorDeclaration.Attributes.Count; i++) {
-				AttributeSection o = constructorDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					constructorDeclaration.Attributes.RemoveAt(i--);
-				else
-					constructorDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < constructorDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = constructorDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					constructorDeclaration.Parameters.RemoveAt(i--);
-				else
-					constructorDeclaration.Parameters[i] = o;
-			}
-			nodeStack.Push(constructorDeclaration.ConstructorInitializer);
-			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
-			constructorDeclaration.ConstructorInitializer = ((ConstructorInitializer)(nodeStack.Pop()));
-			nodeStack.Push(constructorDeclaration.Body);
-			constructorDeclaration.Body.AcceptVisitor(this, data);
-			constructorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
-			Debug.Assert((constructorInitializer != null));
-			Debug.Assert((constructorInitializer.Arguments != null));
-			for (int i = 0; i < constructorInitializer.Arguments.Count; i++) {
-				Expression o = constructorInitializer.Arguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					constructorInitializer.Arguments.RemoveAt(i--);
-				else
-					constructorInitializer.Arguments[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitContinueStatement(ContinueStatement continueStatement, object data) {
-			Debug.Assert((continueStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
-			Debug.Assert((declareDeclaration != null));
-			Debug.Assert((declareDeclaration.Attributes != null));
-			Debug.Assert((declareDeclaration.Parameters != null));
-			Debug.Assert((declareDeclaration.TypeReference != null));
-			for (int i = 0; i < declareDeclaration.Attributes.Count; i++) {
-				AttributeSection o = declareDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					declareDeclaration.Attributes.RemoveAt(i--);
-				else
-					declareDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < declareDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = declareDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					declareDeclaration.Parameters.RemoveAt(i--);
-				else
-					declareDeclaration.Parameters[i] = o;
-			}
-			nodeStack.Push(declareDeclaration.TypeReference);
-			declareDeclaration.TypeReference.AcceptVisitor(this, data);
-			declareDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
-			Debug.Assert((defaultValueExpression != null));
-			Debug.Assert((defaultValueExpression.TypeReference != null));
-			nodeStack.Push(defaultValueExpression.TypeReference);
-			defaultValueExpression.TypeReference.AcceptVisitor(this, data);
-			defaultValueExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
-			Debug.Assert((delegateDeclaration != null));
-			Debug.Assert((delegateDeclaration.Attributes != null));
-			Debug.Assert((delegateDeclaration.ReturnType != null));
-			Debug.Assert((delegateDeclaration.Parameters != null));
-			Debug.Assert((delegateDeclaration.Templates != null));
-			for (int i = 0; i < delegateDeclaration.Attributes.Count; i++) {
-				AttributeSection o = delegateDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					delegateDeclaration.Attributes.RemoveAt(i--);
-				else
-					delegateDeclaration.Attributes[i] = o;
-			}
-			nodeStack.Push(delegateDeclaration.ReturnType);
-			delegateDeclaration.ReturnType.AcceptVisitor(this, data);
-			delegateDeclaration.ReturnType = ((TypeReference)(nodeStack.Pop()));
-			for (int i = 0; i < delegateDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = delegateDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					delegateDeclaration.Parameters.RemoveAt(i--);
-				else
-					delegateDeclaration.Parameters[i] = o;
-			}
-			for (int i = 0; i < delegateDeclaration.Templates.Count; i++) {
-				TemplateDefinition o = delegateDeclaration.Templates[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TemplateDefinition)nodeStack.Pop();
-				if (o == null)
-					delegateDeclaration.Templates.RemoveAt(i--);
-				else
-					delegateDeclaration.Templates[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
-			Debug.Assert((directionExpression != null));
-			Debug.Assert((directionExpression.Expression != null));
-			nodeStack.Push(directionExpression.Expression);
-			directionExpression.Expression.AcceptVisitor(this, data);
-			directionExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
-			Debug.Assert((doLoopStatement != null));
-			Debug.Assert((doLoopStatement.Condition != null));
-			Debug.Assert((doLoopStatement.EmbeddedStatement != null));
-			nodeStack.Push(doLoopStatement.Condition);
-			doLoopStatement.Condition.AcceptVisitor(this, data);
-			doLoopStatement.Condition = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(doLoopStatement.EmbeddedStatement);
-			doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			doLoopStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
-			Debug.Assert((elseIfSection != null));
-			Debug.Assert((elseIfSection.Condition != null));
-			Debug.Assert((elseIfSection.EmbeddedStatement != null));
-			nodeStack.Push(elseIfSection.Condition);
-			elseIfSection.Condition.AcceptVisitor(this, data);
-			elseIfSection.Condition = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(elseIfSection.EmbeddedStatement);
-			elseIfSection.EmbeddedStatement.AcceptVisitor(this, data);
-			elseIfSection.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitEndStatement(EndStatement endStatement, object data) {
-			Debug.Assert((endStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitEraseStatement(EraseStatement eraseStatement, object data) {
-			Debug.Assert((eraseStatement != null));
-			Debug.Assert((eraseStatement.Expressions != null));
-			for (int i = 0; i < eraseStatement.Expressions.Count; i++) {
-				Expression o = eraseStatement.Expressions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					eraseStatement.Expressions.RemoveAt(i--);
-				else
-					eraseStatement.Expressions[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitErrorStatement(ErrorStatement errorStatement, object data) {
-			Debug.Assert((errorStatement != null));
-			Debug.Assert((errorStatement.Expression != null));
-			nodeStack.Push(errorStatement.Expression);
-			errorStatement.Expression.AcceptVisitor(this, data);
-			errorStatement.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
-			Debug.Assert((eventAddRegion != null));
-			Debug.Assert((eventAddRegion.Attributes != null));
-			Debug.Assert((eventAddRegion.Block != null));
-			Debug.Assert((eventAddRegion.Parameters != null));
-			for (int i = 0; i < eventAddRegion.Attributes.Count; i++) {
-				AttributeSection o = eventAddRegion.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					eventAddRegion.Attributes.RemoveAt(i--);
-				else
-					eventAddRegion.Attributes[i] = o;
-			}
-			nodeStack.Push(eventAddRegion.Block);
-			eventAddRegion.Block.AcceptVisitor(this, data);
-			eventAddRegion.Block = ((BlockStatement)(nodeStack.Pop()));
-			for (int i = 0; i < eventAddRegion.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = eventAddRegion.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					eventAddRegion.Parameters.RemoveAt(i--);
-				else
-					eventAddRegion.Parameters[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
-			Debug.Assert((eventDeclaration != null));
-			Debug.Assert((eventDeclaration.Attributes != null));
-			Debug.Assert((eventDeclaration.Parameters != null));
-			Debug.Assert((eventDeclaration.InterfaceImplementations != null));
-			Debug.Assert((eventDeclaration.TypeReference != null));
-			Debug.Assert((eventDeclaration.AddRegion != null));
-			Debug.Assert((eventDeclaration.RemoveRegion != null));
-			Debug.Assert((eventDeclaration.RaiseRegion != null));
-			Debug.Assert((eventDeclaration.Initializer != null));
-			for (int i = 0; i < eventDeclaration.Attributes.Count; i++) {
-				AttributeSection o = eventDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					eventDeclaration.Attributes.RemoveAt(i--);
-				else
-					eventDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < eventDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = eventDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					eventDeclaration.Parameters.RemoveAt(i--);
-				else
-					eventDeclaration.Parameters[i] = o;
-			}
-			for (int i = 0; i < eventDeclaration.InterfaceImplementations.Count; i++) {
-				InterfaceImplementation o = eventDeclaration.InterfaceImplementations[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (InterfaceImplementation)nodeStack.Pop();
-				if (o == null)
-					eventDeclaration.InterfaceImplementations.RemoveAt(i--);
-				else
-					eventDeclaration.InterfaceImplementations[i] = o;
-			}
-			nodeStack.Push(eventDeclaration.TypeReference);
-			eventDeclaration.TypeReference.AcceptVisitor(this, data);
-			eventDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(eventDeclaration.AddRegion);
-			eventDeclaration.AddRegion.AcceptVisitor(this, data);
-			eventDeclaration.AddRegion = ((EventAddRegion)(nodeStack.Pop()));
-			nodeStack.Push(eventDeclaration.RemoveRegion);
-			eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
-			eventDeclaration.RemoveRegion = ((EventRemoveRegion)(nodeStack.Pop()));
-			nodeStack.Push(eventDeclaration.RaiseRegion);
-			eventDeclaration.RaiseRegion.AcceptVisitor(this, data);
-			eventDeclaration.RaiseRegion = ((EventRaiseRegion)(nodeStack.Pop()));
-			nodeStack.Push(eventDeclaration.Initializer);
-			eventDeclaration.Initializer.AcceptVisitor(this, data);
-			eventDeclaration.Initializer = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
-			Debug.Assert((eventRaiseRegion != null));
-			Debug.Assert((eventRaiseRegion.Attributes != null));
-			Debug.Assert((eventRaiseRegion.Block != null));
-			Debug.Assert((eventRaiseRegion.Parameters != null));
-			for (int i = 0; i < eventRaiseRegion.Attributes.Count; i++) {
-				AttributeSection o = eventRaiseRegion.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					eventRaiseRegion.Attributes.RemoveAt(i--);
-				else
-					eventRaiseRegion.Attributes[i] = o;
-			}
-			nodeStack.Push(eventRaiseRegion.Block);
-			eventRaiseRegion.Block.AcceptVisitor(this, data);
-			eventRaiseRegion.Block = ((BlockStatement)(nodeStack.Pop()));
-			for (int i = 0; i < eventRaiseRegion.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = eventRaiseRegion.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					eventRaiseRegion.Parameters.RemoveAt(i--);
-				else
-					eventRaiseRegion.Parameters[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
-			Debug.Assert((eventRemoveRegion != null));
-			Debug.Assert((eventRemoveRegion.Attributes != null));
-			Debug.Assert((eventRemoveRegion.Block != null));
-			Debug.Assert((eventRemoveRegion.Parameters != null));
-			for (int i = 0; i < eventRemoveRegion.Attributes.Count; i++) {
-				AttributeSection o = eventRemoveRegion.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					eventRemoveRegion.Attributes.RemoveAt(i--);
-				else
-					eventRemoveRegion.Attributes[i] = o;
-			}
-			nodeStack.Push(eventRemoveRegion.Block);
-			eventRemoveRegion.Block.AcceptVisitor(this, data);
-			eventRemoveRegion.Block = ((BlockStatement)(nodeStack.Pop()));
-			for (int i = 0; i < eventRemoveRegion.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = eventRemoveRegion.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					eventRemoveRegion.Parameters.RemoveAt(i--);
-				else
-					eventRemoveRegion.Parameters[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitExitStatement(ExitStatement exitStatement, object data) {
-			Debug.Assert((exitStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
-			Debug.Assert((expressionRangeVariable != null));
-			Debug.Assert((expressionRangeVariable.Expression != null));
-			Debug.Assert((expressionRangeVariable.Type != null));
-			nodeStack.Push(expressionRangeVariable.Expression);
-			expressionRangeVariable.Expression.AcceptVisitor(this, data);
-			expressionRangeVariable.Expression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(expressionRangeVariable.Type);
-			expressionRangeVariable.Type.AcceptVisitor(this, data);
-			expressionRangeVariable.Type = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
-			Debug.Assert((expressionStatement != null));
-			Debug.Assert((expressionStatement.Expression != null));
-			nodeStack.Push(expressionStatement.Expression);
-			expressionStatement.Expression.AcceptVisitor(this, data);
-			expressionStatement.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
-			Debug.Assert((externAliasDirective != null));
-			return null;
-		}
-		
-		public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
-			Debug.Assert((fieldDeclaration != null));
-			Debug.Assert((fieldDeclaration.Attributes != null));
-			Debug.Assert((fieldDeclaration.TypeReference != null));
-			Debug.Assert((fieldDeclaration.Fields != null));
-			for (int i = 0; i < fieldDeclaration.Attributes.Count; i++) {
-				AttributeSection o = fieldDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					fieldDeclaration.Attributes.RemoveAt(i--);
-				else
-					fieldDeclaration.Attributes[i] = o;
-			}
-			nodeStack.Push(fieldDeclaration.TypeReference);
-			fieldDeclaration.TypeReference.AcceptVisitor(this, data);
-			fieldDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			for (int i = 0; i < fieldDeclaration.Fields.Count; i++) {
-				VariableDeclaration o = fieldDeclaration.Fields[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (VariableDeclaration)nodeStack.Pop();
-				if (o == null)
-					fieldDeclaration.Fields.RemoveAt(i--);
-				else
-					fieldDeclaration.Fields[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
-			Debug.Assert((foreachStatement != null));
-			Debug.Assert((foreachStatement.TypeReference != null));
-			Debug.Assert((foreachStatement.Expression != null));
-			Debug.Assert((foreachStatement.NextExpression != null));
-			Debug.Assert((foreachStatement.EmbeddedStatement != null));
-			nodeStack.Push(foreachStatement.TypeReference);
-			foreachStatement.TypeReference.AcceptVisitor(this, data);
-			foreachStatement.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(foreachStatement.Expression);
-			foreachStatement.Expression.AcceptVisitor(this, data);
-			foreachStatement.Expression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(foreachStatement.NextExpression);
-			foreachStatement.NextExpression.AcceptVisitor(this, data);
-			foreachStatement.NextExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(foreachStatement.EmbeddedStatement);
-			foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			foreachStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
-			Debug.Assert((forNextStatement != null));
-			Debug.Assert((forNextStatement.Start != null));
-			Debug.Assert((forNextStatement.End != null));
-			Debug.Assert((forNextStatement.Step != null));
-			Debug.Assert((forNextStatement.NextExpressions != null));
-			Debug.Assert((forNextStatement.TypeReference != null));
-			Debug.Assert((forNextStatement.LoopVariableExpression != null));
-			Debug.Assert((forNextStatement.EmbeddedStatement != null));
-			nodeStack.Push(forNextStatement.Start);
-			forNextStatement.Start.AcceptVisitor(this, data);
-			forNextStatement.Start = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(forNextStatement.End);
-			forNextStatement.End.AcceptVisitor(this, data);
-			forNextStatement.End = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(forNextStatement.Step);
-			forNextStatement.Step.AcceptVisitor(this, data);
-			forNextStatement.Step = ((Expression)(nodeStack.Pop()));
-			for (int i = 0; i < forNextStatement.NextExpressions.Count; i++) {
-				Expression o = forNextStatement.NextExpressions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					forNextStatement.NextExpressions.RemoveAt(i--);
-				else
-					forNextStatement.NextExpressions[i] = o;
-			}
-			nodeStack.Push(forNextStatement.TypeReference);
-			forNextStatement.TypeReference.AcceptVisitor(this, data);
-			forNextStatement.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(forNextStatement.LoopVariableExpression);
-			forNextStatement.LoopVariableExpression.AcceptVisitor(this, data);
-			forNextStatement.LoopVariableExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(forNextStatement.EmbeddedStatement);
-			forNextStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			forNextStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitGotoStatement(GotoStatement gotoStatement, object data) {
-			Debug.Assert((gotoStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
-			Debug.Assert((identifierExpression != null));
-			Debug.Assert((identifierExpression.TypeArguments != null));
-			for (int i = 0; i < identifierExpression.TypeArguments.Count; i++) {
-				TypeReference o = identifierExpression.TypeArguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TypeReference)nodeStack.Pop();
-				if (o == null)
-					identifierExpression.TypeArguments.RemoveAt(i--);
-				else
-					identifierExpression.TypeArguments[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
-			Debug.Assert((ifElseStatement != null));
-			Debug.Assert((ifElseStatement.Condition != null));
-			Debug.Assert((ifElseStatement.TrueStatement != null));
-			Debug.Assert((ifElseStatement.FalseStatement != null));
-			Debug.Assert((ifElseStatement.ElseIfSections != null));
-			nodeStack.Push(ifElseStatement.Condition);
-			ifElseStatement.Condition.AcceptVisitor(this, data);
-			ifElseStatement.Condition = ((Expression)(nodeStack.Pop()));
-			for (int i = 0; i < ifElseStatement.TrueStatement.Count; i++) {
-				Statement o = ifElseStatement.TrueStatement[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Statement)nodeStack.Pop();
-				if (o == null)
-					ifElseStatement.TrueStatement.RemoveAt(i--);
-				else
-					ifElseStatement.TrueStatement[i] = o;
-			}
-			for (int i = 0; i < ifElseStatement.FalseStatement.Count; i++) {
-				Statement o = ifElseStatement.FalseStatement[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Statement)nodeStack.Pop();
-				if (o == null)
-					ifElseStatement.FalseStatement.RemoveAt(i--);
-				else
-					ifElseStatement.FalseStatement[i] = o;
-			}
-			for (int i = 0; i < ifElseStatement.ElseIfSections.Count; i++) {
-				ElseIfSection o = ifElseStatement.ElseIfSections[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ElseIfSection)nodeStack.Pop();
-				if (o == null)
-					ifElseStatement.ElseIfSections.RemoveAt(i--);
-				else
-					ifElseStatement.ElseIfSections[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
-			Debug.Assert((innerClassTypeReference != null));
-			Debug.Assert((innerClassTypeReference.GenericTypes != null));
-			Debug.Assert((innerClassTypeReference.BaseType != null));
-			for (int i = 0; i < innerClassTypeReference.GenericTypes.Count; i++) {
-				TypeReference o = innerClassTypeReference.GenericTypes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TypeReference)nodeStack.Pop();
-				if (o == null)
-					innerClassTypeReference.GenericTypes.RemoveAt(i--);
-				else
-					innerClassTypeReference.GenericTypes[i] = o;
-			}
-			nodeStack.Push(innerClassTypeReference.BaseType);
-			innerClassTypeReference.BaseType.AcceptVisitor(this, data);
-			innerClassTypeReference.BaseType = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
-			Debug.Assert((interfaceImplementation != null));
-			Debug.Assert((interfaceImplementation.InterfaceType != null));
-			nodeStack.Push(interfaceImplementation.InterfaceType);
-			interfaceImplementation.InterfaceType.AcceptVisitor(this, data);
-			interfaceImplementation.InterfaceType = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
-			Debug.Assert((invocationExpression != null));
-			Debug.Assert((invocationExpression.TargetObject != null));
-			Debug.Assert((invocationExpression.Arguments != null));
-			nodeStack.Push(invocationExpression.TargetObject);
-			invocationExpression.TargetObject.AcceptVisitor(this, data);
-			invocationExpression.TargetObject = ((Expression)(nodeStack.Pop()));
-			for (int i = 0; i < invocationExpression.Arguments.Count; i++) {
-				Expression o = invocationExpression.Arguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					invocationExpression.Arguments.RemoveAt(i--);
-				else
-					invocationExpression.Arguments[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitLabelStatement(LabelStatement labelStatement, object data) {
-			Debug.Assert((labelStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
-			Debug.Assert((lambdaExpression != null));
-			Debug.Assert((lambdaExpression.Parameters != null));
-			Debug.Assert((lambdaExpression.StatementBody != null));
-			Debug.Assert((lambdaExpression.ExpressionBody != null));
-			Debug.Assert((lambdaExpression.ReturnType != null));
-			for (int i = 0; i < lambdaExpression.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = lambdaExpression.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					lambdaExpression.Parameters.RemoveAt(i--);
-				else
-					lambdaExpression.Parameters[i] = o;
-			}
-			nodeStack.Push(lambdaExpression.StatementBody);
-			lambdaExpression.StatementBody.AcceptVisitor(this, data);
-			lambdaExpression.StatementBody = ((Statement)(nodeStack.Pop()));
-			nodeStack.Push(lambdaExpression.ExpressionBody);
-			lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
-			lambdaExpression.ExpressionBody = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(lambdaExpression.ReturnType);
-			lambdaExpression.ReturnType.AcceptVisitor(this, data);
-			lambdaExpression.ReturnType = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
-			Debug.Assert((localVariableDeclaration != null));
-			Debug.Assert((localVariableDeclaration.TypeReference != null));
-			Debug.Assert((localVariableDeclaration.Variables != null));
-			nodeStack.Push(localVariableDeclaration.TypeReference);
-			localVariableDeclaration.TypeReference.AcceptVisitor(this, data);
-			localVariableDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			for (int i = 0; i < localVariableDeclaration.Variables.Count; i++) {
-				VariableDeclaration o = localVariableDeclaration.Variables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (VariableDeclaration)nodeStack.Pop();
-				if (o == null)
-					localVariableDeclaration.Variables.RemoveAt(i--);
-				else
-					localVariableDeclaration.Variables[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitLockStatement(LockStatement lockStatement, object data) {
-			Debug.Assert((lockStatement != null));
-			Debug.Assert((lockStatement.LockExpression != null));
-			Debug.Assert((lockStatement.EmbeddedStatement != null));
-			nodeStack.Push(lockStatement.LockExpression);
-			lockStatement.LockExpression.AcceptVisitor(this, data);
-			lockStatement.LockExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(lockStatement.EmbeddedStatement);
-			lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			lockStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
-			Debug.Assert((memberInitializerExpression != null));
-			Debug.Assert((memberInitializerExpression.Expression != null));
-			nodeStack.Push(memberInitializerExpression.Expression);
-			memberInitializerExpression.Expression.AcceptVisitor(this, data);
-			memberInitializerExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
-			Debug.Assert((memberReferenceExpression != null));
-			Debug.Assert((memberReferenceExpression.TargetObject != null));
-			Debug.Assert((memberReferenceExpression.TypeArguments != null));
-			nodeStack.Push(memberReferenceExpression.TargetObject);
-			memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
-			memberReferenceExpression.TargetObject = ((Expression)(nodeStack.Pop()));
-			for (int i = 0; i < memberReferenceExpression.TypeArguments.Count; i++) {
-				TypeReference o = memberReferenceExpression.TypeArguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TypeReference)nodeStack.Pop();
-				if (o == null)
-					memberReferenceExpression.TypeArguments.RemoveAt(i--);
-				else
-					memberReferenceExpression.TypeArguments[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
-			Debug.Assert((methodDeclaration != null));
-			Debug.Assert((methodDeclaration.Attributes != null));
-			Debug.Assert((methodDeclaration.Parameters != null));
-			Debug.Assert((methodDeclaration.InterfaceImplementations != null));
-			Debug.Assert((methodDeclaration.TypeReference != null));
-			Debug.Assert((methodDeclaration.Body != null));
-			Debug.Assert((methodDeclaration.Templates != null));
-			for (int i = 0; i < methodDeclaration.Attributes.Count; i++) {
-				AttributeSection o = methodDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					methodDeclaration.Attributes.RemoveAt(i--);
-				else
-					methodDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < methodDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = methodDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					methodDeclaration.Parameters.RemoveAt(i--);
-				else
-					methodDeclaration.Parameters[i] = o;
-			}
-			for (int i = 0; i < methodDeclaration.InterfaceImplementations.Count; i++) {
-				InterfaceImplementation o = methodDeclaration.InterfaceImplementations[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (InterfaceImplementation)nodeStack.Pop();
-				if (o == null)
-					methodDeclaration.InterfaceImplementations.RemoveAt(i--);
-				else
-					methodDeclaration.InterfaceImplementations[i] = o;
-			}
-			nodeStack.Push(methodDeclaration.TypeReference);
-			methodDeclaration.TypeReference.AcceptVisitor(this, data);
-			methodDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(methodDeclaration.Body);
-			methodDeclaration.Body.AcceptVisitor(this, data);
-			methodDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
-			for (int i = 0; i < methodDeclaration.Templates.Count; i++) {
-				TemplateDefinition o = methodDeclaration.Templates[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TemplateDefinition)nodeStack.Pop();
-				if (o == null)
-					methodDeclaration.Templates.RemoveAt(i--);
-				else
-					methodDeclaration.Templates[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
-			Debug.Assert((namedArgumentExpression != null));
-			Debug.Assert((namedArgumentExpression.Expression != null));
-			nodeStack.Push(namedArgumentExpression.Expression);
-			namedArgumentExpression.Expression.AcceptVisitor(this, data);
-			namedArgumentExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
-			Debug.Assert((namespaceDeclaration != null));
-			for (int i = 0; i < namespaceDeclaration.Children.Count; i++) {
-				INode o = namespaceDeclaration.Children[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = nodeStack.Pop();
-				if (o == null)
-					namespaceDeclaration.Children.RemoveAt(i--);
-				else
-					namespaceDeclaration.Children[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
-			Debug.Assert((objectCreateExpression != null));
-			Debug.Assert((objectCreateExpression.CreateType != null));
-			Debug.Assert((objectCreateExpression.Parameters != null));
-			Debug.Assert((objectCreateExpression.ObjectInitializer != null));
-			nodeStack.Push(objectCreateExpression.CreateType);
-			objectCreateExpression.CreateType.AcceptVisitor(this, data);
-			objectCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop()));
-			for (int i = 0; i < objectCreateExpression.Parameters.Count; i++) {
-				Expression o = objectCreateExpression.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					objectCreateExpression.Parameters.RemoveAt(i--);
-				else
-					objectCreateExpression.Parameters[i] = o;
-			}
-			nodeStack.Push(objectCreateExpression.ObjectInitializer);
-			objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
-			objectCreateExpression.ObjectInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
-			Debug.Assert((onErrorStatement != null));
-			Debug.Assert((onErrorStatement.EmbeddedStatement != null));
-			nodeStack.Push(onErrorStatement.EmbeddedStatement);
-			onErrorStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			onErrorStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
-			Debug.Assert((operatorDeclaration != null));
-			Debug.Assert((operatorDeclaration.Attributes != null));
-			Debug.Assert((operatorDeclaration.Parameters != null));
-			Debug.Assert((operatorDeclaration.InterfaceImplementations != null));
-			Debug.Assert((operatorDeclaration.TypeReference != null));
-			Debug.Assert((operatorDeclaration.Body != null));
-			Debug.Assert((operatorDeclaration.Templates != null));
-			for (int i = 0; i < operatorDeclaration.Attributes.Count; i++) {
-				AttributeSection o = operatorDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					operatorDeclaration.Attributes.RemoveAt(i--);
-				else
-					operatorDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < operatorDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = operatorDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					operatorDeclaration.Parameters.RemoveAt(i--);
-				else
-					operatorDeclaration.Parameters[i] = o;
-			}
-			for (int i = 0; i < operatorDeclaration.InterfaceImplementations.Count; i++) {
-				InterfaceImplementation o = operatorDeclaration.InterfaceImplementations[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (InterfaceImplementation)nodeStack.Pop();
-				if (o == null)
-					operatorDeclaration.InterfaceImplementations.RemoveAt(i--);
-				else
-					operatorDeclaration.InterfaceImplementations[i] = o;
-			}
-			nodeStack.Push(operatorDeclaration.TypeReference);
-			operatorDeclaration.TypeReference.AcceptVisitor(this, data);
-			operatorDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(operatorDeclaration.Body);
-			operatorDeclaration.Body.AcceptVisitor(this, data);
-			operatorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
-			for (int i = 0; i < operatorDeclaration.Templates.Count; i++) {
-				TemplateDefinition o = operatorDeclaration.Templates[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TemplateDefinition)nodeStack.Pop();
-				if (o == null)
-					operatorDeclaration.Templates.RemoveAt(i--);
-				else
-					operatorDeclaration.Templates[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
-			Debug.Assert((optionDeclaration != null));
-			return null;
-		}
-		
-		public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
-			Debug.Assert((parameterDeclarationExpression != null));
-			Debug.Assert((parameterDeclarationExpression.Attributes != null));
-			Debug.Assert((parameterDeclarationExpression.TypeReference != null));
-			Debug.Assert((parameterDeclarationExpression.DefaultValue != null));
-			for (int i = 0; i < parameterDeclarationExpression.Attributes.Count; i++) {
-				AttributeSection o = parameterDeclarationExpression.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					parameterDeclarationExpression.Attributes.RemoveAt(i--);
-				else
-					parameterDeclarationExpression.Attributes[i] = o;
-			}
-			nodeStack.Push(parameterDeclarationExpression.TypeReference);
-			parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data);
-			parameterDeclarationExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(parameterDeclarationExpression.DefaultValue);
-			parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data);
-			parameterDeclarationExpression.DefaultValue = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
-			Debug.Assert((parenthesizedExpression != null));
-			Debug.Assert((parenthesizedExpression.Expression != null));
-			nodeStack.Push(parenthesizedExpression.Expression);
-			parenthesizedExpression.Expression.AcceptVisitor(this, data);
-			parenthesizedExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
-			Debug.Assert((primitiveExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
-			Debug.Assert((propertyDeclaration != null));
-			Debug.Assert((propertyDeclaration.Attributes != null));
-			Debug.Assert((propertyDeclaration.Parameters != null));
-			Debug.Assert((propertyDeclaration.InterfaceImplementations != null));
-			Debug.Assert((propertyDeclaration.TypeReference != null));
-			Debug.Assert((propertyDeclaration.GetRegion != null));
-			Debug.Assert((propertyDeclaration.SetRegion != null));
-			Debug.Assert((propertyDeclaration.Initializer != null));
-			for (int i = 0; i < propertyDeclaration.Attributes.Count; i++) {
-				AttributeSection o = propertyDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					propertyDeclaration.Attributes.RemoveAt(i--);
-				else
-					propertyDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < propertyDeclaration.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = propertyDeclaration.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					propertyDeclaration.Parameters.RemoveAt(i--);
-				else
-					propertyDeclaration.Parameters[i] = o;
-			}
-			for (int i = 0; i < propertyDeclaration.InterfaceImplementations.Count; i++) {
-				InterfaceImplementation o = propertyDeclaration.InterfaceImplementations[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (InterfaceImplementation)nodeStack.Pop();
-				if (o == null)
-					propertyDeclaration.InterfaceImplementations.RemoveAt(i--);
-				else
-					propertyDeclaration.InterfaceImplementations[i] = o;
-			}
-			nodeStack.Push(propertyDeclaration.TypeReference);
-			propertyDeclaration.TypeReference.AcceptVisitor(this, data);
-			propertyDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(propertyDeclaration.GetRegion);
-			propertyDeclaration.GetRegion.AcceptVisitor(this, data);
-			propertyDeclaration.GetRegion = ((PropertyGetRegion)(nodeStack.Pop()));
-			nodeStack.Push(propertyDeclaration.SetRegion);
-			propertyDeclaration.SetRegion.AcceptVisitor(this, data);
-			propertyDeclaration.SetRegion = ((PropertySetRegion)(nodeStack.Pop()));
-			nodeStack.Push(propertyDeclaration.Initializer);
-			propertyDeclaration.Initializer.AcceptVisitor(this, data);
-			propertyDeclaration.Initializer = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
-			Debug.Assert((propertyGetRegion != null));
-			Debug.Assert((propertyGetRegion.Attributes != null));
-			Debug.Assert((propertyGetRegion.Block != null));
-			for (int i = 0; i < propertyGetRegion.Attributes.Count; i++) {
-				AttributeSection o = propertyGetRegion.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					propertyGetRegion.Attributes.RemoveAt(i--);
-				else
-					propertyGetRegion.Attributes[i] = o;
-			}
-			nodeStack.Push(propertyGetRegion.Block);
-			propertyGetRegion.Block.AcceptVisitor(this, data);
-			propertyGetRegion.Block = ((BlockStatement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
-			Debug.Assert((propertySetRegion != null));
-			Debug.Assert((propertySetRegion.Attributes != null));
-			Debug.Assert((propertySetRegion.Block != null));
-			Debug.Assert((propertySetRegion.Parameters != null));
-			for (int i = 0; i < propertySetRegion.Attributes.Count; i++) {
-				AttributeSection o = propertySetRegion.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					propertySetRegion.Attributes.RemoveAt(i--);
-				else
-					propertySetRegion.Attributes[i] = o;
-			}
-			nodeStack.Push(propertySetRegion.Block);
-			propertySetRegion.Block.AcceptVisitor(this, data);
-			propertySetRegion.Block = ((BlockStatement)(nodeStack.Pop()));
-			for (int i = 0; i < propertySetRegion.Parameters.Count; i++) {
-				ParameterDeclarationExpression o = propertySetRegion.Parameters[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ParameterDeclarationExpression)nodeStack.Pop();
-				if (o == null)
-					propertySetRegion.Parameters.RemoveAt(i--);
-				else
-					propertySetRegion.Parameters[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
-			Debug.Assert((queryExpression != null));
-			Debug.Assert((queryExpression.Clauses != null));
-			for (int i = 0; i < queryExpression.Clauses.Count; i++) {
-				QueryExpressionClause o = queryExpression.Clauses[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (QueryExpressionClause)nodeStack.Pop();
-				if (o == null)
-					queryExpression.Clauses.RemoveAt(i--);
-				else
-					queryExpression.Clauses[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
-			Debug.Assert((queryExpressionAggregateClause != null));
-			Debug.Assert((queryExpressionAggregateClause.Source != null));
-			Debug.Assert((queryExpressionAggregateClause.MiddleClauses != null));
-			Debug.Assert((queryExpressionAggregateClause.IntoVariables != null));
-			nodeStack.Push(queryExpressionAggregateClause.Source);
-			queryExpressionAggregateClause.Source.AcceptVisitor(this, data);
-			queryExpressionAggregateClause.Source = ((CollectionRangeVariable)(nodeStack.Pop()));
-			for (int i = 0; i < queryExpressionAggregateClause.MiddleClauses.Count; i++) {
-				QueryExpressionClause o = queryExpressionAggregateClause.MiddleClauses[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (QueryExpressionClause)nodeStack.Pop();
-				if (o == null)
-					queryExpressionAggregateClause.MiddleClauses.RemoveAt(i--);
-				else
-					queryExpressionAggregateClause.MiddleClauses[i] = o;
-			}
-			for (int i = 0; i < queryExpressionAggregateClause.IntoVariables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionAggregateClause.IntoVariables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionAggregateClause.IntoVariables.RemoveAt(i--);
-				else
-					queryExpressionAggregateClause.IntoVariables[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
-			Debug.Assert((queryExpressionDistinctClause != null));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
-			Debug.Assert((queryExpressionFromClause != null));
-			Debug.Assert((queryExpressionFromClause.Sources != null));
-			for (int i = 0; i < queryExpressionFromClause.Sources.Count; i++) {
-				CollectionRangeVariable o = queryExpressionFromClause.Sources[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (CollectionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionFromClause.Sources.RemoveAt(i--);
-				else
-					queryExpressionFromClause.Sources[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
-			Debug.Assert((queryExpressionGroupClause != null));
-			Debug.Assert((queryExpressionGroupClause.Projection != null));
-			Debug.Assert((queryExpressionGroupClause.GroupBy != null));
-			nodeStack.Push(queryExpressionGroupClause.Projection);
-			queryExpressionGroupClause.Projection.AcceptVisitor(this, data);
-			queryExpressionGroupClause.Projection = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(queryExpressionGroupClause.GroupBy);
-			queryExpressionGroupClause.GroupBy.AcceptVisitor(this, data);
-			queryExpressionGroupClause.GroupBy = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
-			Debug.Assert((queryExpressionGroupJoinVBClause != null));
-			Debug.Assert((queryExpressionGroupJoinVBClause.JoinClause != null));
-			Debug.Assert((queryExpressionGroupJoinVBClause.IntoVariables != null));
-			nodeStack.Push(queryExpressionGroupJoinVBClause.JoinClause);
-			queryExpressionGroupJoinVBClause.JoinClause.AcceptVisitor(this, data);
-			queryExpressionGroupJoinVBClause.JoinClause = ((QueryExpressionJoinVBClause)(nodeStack.Pop()));
-			for (int i = 0; i < queryExpressionGroupJoinVBClause.IntoVariables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionGroupJoinVBClause.IntoVariables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionGroupJoinVBClause.IntoVariables.RemoveAt(i--);
-				else
-					queryExpressionGroupJoinVBClause.IntoVariables[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
-			Debug.Assert((queryExpressionGroupVBClause != null));
-			Debug.Assert((queryExpressionGroupVBClause.GroupVariables != null));
-			Debug.Assert((queryExpressionGroupVBClause.ByVariables != null));
-			Debug.Assert((queryExpressionGroupVBClause.IntoVariables != null));
-			for (int i = 0; i < queryExpressionGroupVBClause.GroupVariables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionGroupVBClause.GroupVariables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionGroupVBClause.GroupVariables.RemoveAt(i--);
-				else
-					queryExpressionGroupVBClause.GroupVariables[i] = o;
-			}
-			for (int i = 0; i < queryExpressionGroupVBClause.ByVariables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionGroupVBClause.ByVariables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionGroupVBClause.ByVariables.RemoveAt(i--);
-				else
-					queryExpressionGroupVBClause.ByVariables[i] = o;
-			}
-			for (int i = 0; i < queryExpressionGroupVBClause.IntoVariables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionGroupVBClause.IntoVariables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionGroupVBClause.IntoVariables.RemoveAt(i--);
-				else
-					queryExpressionGroupVBClause.IntoVariables[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
-			Debug.Assert((queryExpressionJoinClause != null));
-			Debug.Assert((queryExpressionJoinClause.OnExpression != null));
-			Debug.Assert((queryExpressionJoinClause.EqualsExpression != null));
-			Debug.Assert((queryExpressionJoinClause.Source != null));
-			nodeStack.Push(queryExpressionJoinClause.OnExpression);
-			queryExpressionJoinClause.OnExpression.AcceptVisitor(this, data);
-			queryExpressionJoinClause.OnExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(queryExpressionJoinClause.EqualsExpression);
-			queryExpressionJoinClause.EqualsExpression.AcceptVisitor(this, data);
-			queryExpressionJoinClause.EqualsExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(queryExpressionJoinClause.Source);
-			queryExpressionJoinClause.Source.AcceptVisitor(this, data);
-			queryExpressionJoinClause.Source = ((CollectionRangeVariable)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
-			Debug.Assert((queryExpressionJoinConditionVB != null));
-			Debug.Assert((queryExpressionJoinConditionVB.LeftSide != null));
-			Debug.Assert((queryExpressionJoinConditionVB.RightSide != null));
-			nodeStack.Push(queryExpressionJoinConditionVB.LeftSide);
-			queryExpressionJoinConditionVB.LeftSide.AcceptVisitor(this, data);
-			queryExpressionJoinConditionVB.LeftSide = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(queryExpressionJoinConditionVB.RightSide);
-			queryExpressionJoinConditionVB.RightSide.AcceptVisitor(this, data);
-			queryExpressionJoinConditionVB.RightSide = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
-			Debug.Assert((queryExpressionJoinVBClause != null));
-			Debug.Assert((queryExpressionJoinVBClause.JoinVariable != null));
-			Debug.Assert((queryExpressionJoinVBClause.SubJoin != null));
-			Debug.Assert((queryExpressionJoinVBClause.Conditions != null));
-			nodeStack.Push(queryExpressionJoinVBClause.JoinVariable);
-			queryExpressionJoinVBClause.JoinVariable.AcceptVisitor(this, data);
-			queryExpressionJoinVBClause.JoinVariable = ((CollectionRangeVariable)(nodeStack.Pop()));
-			nodeStack.Push(queryExpressionJoinVBClause.SubJoin);
-			queryExpressionJoinVBClause.SubJoin.AcceptVisitor(this, data);
-			queryExpressionJoinVBClause.SubJoin = ((QueryExpressionJoinVBClause)(nodeStack.Pop()));
-			for (int i = 0; i < queryExpressionJoinVBClause.Conditions.Count; i++) {
-				QueryExpressionJoinConditionVB o = queryExpressionJoinVBClause.Conditions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (QueryExpressionJoinConditionVB)nodeStack.Pop();
-				if (o == null)
-					queryExpressionJoinVBClause.Conditions.RemoveAt(i--);
-				else
-					queryExpressionJoinVBClause.Conditions[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
-			Debug.Assert((queryExpressionLetClause != null));
-			Debug.Assert((queryExpressionLetClause.Expression != null));
-			nodeStack.Push(queryExpressionLetClause.Expression);
-			queryExpressionLetClause.Expression.AcceptVisitor(this, data);
-			queryExpressionLetClause.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionLetVBClause(QueryExpressionLetVBClause queryExpressionLetVBClause, object data) {
-			Debug.Assert((queryExpressionLetVBClause != null));
-			Debug.Assert((queryExpressionLetVBClause.Variables != null));
-			for (int i = 0; i < queryExpressionLetVBClause.Variables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionLetVBClause.Variables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionLetVBClause.Variables.RemoveAt(i--);
-				else
-					queryExpressionLetVBClause.Variables[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
-			Debug.Assert((queryExpressionOrderClause != null));
-			Debug.Assert((queryExpressionOrderClause.Orderings != null));
-			for (int i = 0; i < queryExpressionOrderClause.Orderings.Count; i++) {
-				QueryExpressionOrdering o = queryExpressionOrderClause.Orderings[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (QueryExpressionOrdering)nodeStack.Pop();
-				if (o == null)
-					queryExpressionOrderClause.Orderings.RemoveAt(i--);
-				else
-					queryExpressionOrderClause.Orderings[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
-			Debug.Assert((queryExpressionOrdering != null));
-			Debug.Assert((queryExpressionOrdering.Criteria != null));
-			nodeStack.Push(queryExpressionOrdering.Criteria);
-			queryExpressionOrdering.Criteria.AcceptVisitor(this, data);
-			queryExpressionOrdering.Criteria = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
-			Debug.Assert((queryExpressionPartitionVBClause != null));
-			Debug.Assert((queryExpressionPartitionVBClause.Expression != null));
-			nodeStack.Push(queryExpressionPartitionVBClause.Expression);
-			queryExpressionPartitionVBClause.Expression.AcceptVisitor(this, data);
-			queryExpressionPartitionVBClause.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
-			Debug.Assert((queryExpressionSelectClause != null));
-			Debug.Assert((queryExpressionSelectClause.Projection != null));
-			nodeStack.Push(queryExpressionSelectClause.Projection);
-			queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
-			queryExpressionSelectClause.Projection = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
-			Debug.Assert((queryExpressionSelectVBClause != null));
-			Debug.Assert((queryExpressionSelectVBClause.Variables != null));
-			for (int i = 0; i < queryExpressionSelectVBClause.Variables.Count; i++) {
-				ExpressionRangeVariable o = queryExpressionSelectVBClause.Variables[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (ExpressionRangeVariable)nodeStack.Pop();
-				if (o == null)
-					queryExpressionSelectVBClause.Variables.RemoveAt(i--);
-				else
-					queryExpressionSelectVBClause.Variables[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
-			Debug.Assert((queryExpressionWhereClause != null));
-			Debug.Assert((queryExpressionWhereClause.Condition != null));
-			nodeStack.Push(queryExpressionWhereClause.Condition);
-			queryExpressionWhereClause.Condition.AcceptVisitor(this, data);
-			queryExpressionWhereClause.Condition = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
-			Debug.Assert((raiseEventStatement != null));
-			Debug.Assert((raiseEventStatement.Arguments != null));
-			for (int i = 0; i < raiseEventStatement.Arguments.Count; i++) {
-				Expression o = raiseEventStatement.Arguments[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Expression)nodeStack.Pop();
-				if (o == null)
-					raiseEventStatement.Arguments.RemoveAt(i--);
-				else
-					raiseEventStatement.Arguments[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
-			Debug.Assert((reDimStatement != null));
-			Debug.Assert((reDimStatement.ReDimClauses != null));
-			for (int i = 0; i < reDimStatement.ReDimClauses.Count; i++) {
-				InvocationExpression o = reDimStatement.ReDimClauses[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (InvocationExpression)nodeStack.Pop();
-				if (o == null)
-					reDimStatement.ReDimClauses.RemoveAt(i--);
-				else
-					reDimStatement.ReDimClauses[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
-			Debug.Assert((removeHandlerStatement != null));
-			Debug.Assert((removeHandlerStatement.EventExpression != null));
-			Debug.Assert((removeHandlerStatement.HandlerExpression != null));
-			nodeStack.Push(removeHandlerStatement.EventExpression);
-			removeHandlerStatement.EventExpression.AcceptVisitor(this, data);
-			removeHandlerStatement.EventExpression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(removeHandlerStatement.HandlerExpression);
-			removeHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
-			removeHandlerStatement.HandlerExpression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
-			Debug.Assert((resumeStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitReturnStatement(ReturnStatement returnStatement, object data) {
-			Debug.Assert((returnStatement != null));
-			Debug.Assert((returnStatement.Expression != null));
-			nodeStack.Push(returnStatement.Expression);
-			returnStatement.Expression.AcceptVisitor(this, data);
-			returnStatement.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitStopStatement(StopStatement stopStatement, object data) {
-			Debug.Assert((stopStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitSwitchSection(SwitchSection switchSection, object data) {
-			Debug.Assert((switchSection != null));
-			Debug.Assert((switchSection.SwitchLabels != null));
-			for (int i = 0; i < switchSection.SwitchLabels.Count; i++) {
-				CaseLabel o = switchSection.SwitchLabels[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (CaseLabel)nodeStack.Pop();
-				if (o == null)
-					switchSection.SwitchLabels.RemoveAt(i--);
-				else
-					switchSection.SwitchLabels[i] = o;
-			}
-			for (int i = 0; i < switchSection.Children.Count; i++) {
-				INode o = switchSection.Children[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = nodeStack.Pop();
-				if (o == null)
-					switchSection.Children.RemoveAt(i--);
-				else
-					switchSection.Children[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
-			Debug.Assert((switchStatement != null));
-			Debug.Assert((switchStatement.SwitchExpression != null));
-			Debug.Assert((switchStatement.SwitchSections != null));
-			nodeStack.Push(switchStatement.SwitchExpression);
-			switchStatement.SwitchExpression.AcceptVisitor(this, data);
-			switchStatement.SwitchExpression = ((Expression)(nodeStack.Pop()));
-			for (int i = 0; i < switchStatement.SwitchSections.Count; i++) {
-				SwitchSection o = switchStatement.SwitchSections[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (SwitchSection)nodeStack.Pop();
-				if (o == null)
-					switchStatement.SwitchSections.RemoveAt(i--);
-				else
-					switchStatement.SwitchSections[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
-			Debug.Assert((templateDefinition != null));
-			Debug.Assert((templateDefinition.Attributes != null));
-			Debug.Assert((templateDefinition.Bases != null));
-			for (int i = 0; i < templateDefinition.Attributes.Count; i++) {
-				AttributeSection o = templateDefinition.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					templateDefinition.Attributes.RemoveAt(i--);
-				else
-					templateDefinition.Attributes[i] = o;
-			}
-			for (int i = 0; i < templateDefinition.Bases.Count; i++) {
-				TypeReference o = templateDefinition.Bases[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TypeReference)nodeStack.Pop();
-				if (o == null)
-					templateDefinition.Bases.RemoveAt(i--);
-				else
-					templateDefinition.Bases[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
-			Debug.Assert((thisReferenceExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitThrowStatement(ThrowStatement throwStatement, object data) {
-			Debug.Assert((throwStatement != null));
-			Debug.Assert((throwStatement.Expression != null));
-			nodeStack.Push(throwStatement.Expression);
-			throwStatement.Expression.AcceptVisitor(this, data);
-			throwStatement.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
-			Debug.Assert((tryCatchStatement != null));
-			Debug.Assert((tryCatchStatement.StatementBlock != null));
-			Debug.Assert((tryCatchStatement.CatchClauses != null));
-			Debug.Assert((tryCatchStatement.FinallyBlock != null));
-			nodeStack.Push(tryCatchStatement.StatementBlock);
-			tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
-			tryCatchStatement.StatementBlock = ((Statement)(nodeStack.Pop()));
-			for (int i = 0; i < tryCatchStatement.CatchClauses.Count; i++) {
-				CatchClause o = tryCatchStatement.CatchClauses[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (CatchClause)nodeStack.Pop();
-				if (o == null)
-					tryCatchStatement.CatchClauses.RemoveAt(i--);
-				else
-					tryCatchStatement.CatchClauses[i] = o;
-			}
-			nodeStack.Push(tryCatchStatement.FinallyBlock);
-			tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
-			tryCatchStatement.FinallyBlock = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
-			Debug.Assert((typeDeclaration != null));
-			Debug.Assert((typeDeclaration.Attributes != null));
-			Debug.Assert((typeDeclaration.BaseTypes != null));
-			Debug.Assert((typeDeclaration.Templates != null));
-			for (int i = 0; i < typeDeclaration.Attributes.Count; i++) {
-				AttributeSection o = typeDeclaration.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (AttributeSection)nodeStack.Pop();
-				if (o == null)
-					typeDeclaration.Attributes.RemoveAt(i--);
-				else
-					typeDeclaration.Attributes[i] = o;
-			}
-			for (int i = 0; i < typeDeclaration.BaseTypes.Count; i++) {
-				TypeReference o = typeDeclaration.BaseTypes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TypeReference)nodeStack.Pop();
-				if (o == null)
-					typeDeclaration.BaseTypes.RemoveAt(i--);
-				else
-					typeDeclaration.BaseTypes[i] = o;
-			}
-			for (int i = 0; i < typeDeclaration.Templates.Count; i++) {
-				TemplateDefinition o = typeDeclaration.Templates[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TemplateDefinition)nodeStack.Pop();
-				if (o == null)
-					typeDeclaration.Templates.RemoveAt(i--);
-				else
-					typeDeclaration.Templates[i] = o;
-			}
-			for (int i = 0; i < typeDeclaration.Children.Count; i++) {
-				INode o = typeDeclaration.Children[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = nodeStack.Pop();
-				if (o == null)
-					typeDeclaration.Children.RemoveAt(i--);
-				else
-					typeDeclaration.Children[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
-			Debug.Assert((typeOfExpression != null));
-			Debug.Assert((typeOfExpression.TypeReference != null));
-			nodeStack.Push(typeOfExpression.TypeReference);
-			typeOfExpression.TypeReference.AcceptVisitor(this, data);
-			typeOfExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
-			Debug.Assert((typeOfIsExpression != null));
-			Debug.Assert((typeOfIsExpression.Expression != null));
-			Debug.Assert((typeOfIsExpression.TypeReference != null));
-			nodeStack.Push(typeOfIsExpression.Expression);
-			typeOfIsExpression.Expression.AcceptVisitor(this, data);
-			typeOfIsExpression.Expression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(typeOfIsExpression.TypeReference);
-			typeOfIsExpression.TypeReference.AcceptVisitor(this, data);
-			typeOfIsExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitTypeReference(TypeReference typeReference, object data) {
-			Debug.Assert((typeReference != null));
-			Debug.Assert((typeReference.GenericTypes != null));
-			for (int i = 0; i < typeReference.GenericTypes.Count; i++) {
-				TypeReference o = typeReference.GenericTypes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (TypeReference)nodeStack.Pop();
-				if (o == null)
-					typeReference.GenericTypes.RemoveAt(i--);
-				else
-					typeReference.GenericTypes[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
-			Debug.Assert((typeReferenceExpression != null));
-			Debug.Assert((typeReferenceExpression.TypeReference != null));
-			nodeStack.Push(typeReferenceExpression.TypeReference);
-			typeReferenceExpression.TypeReference.AcceptVisitor(this, data);
-			typeReferenceExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
-			Debug.Assert((unaryOperatorExpression != null));
-			Debug.Assert((unaryOperatorExpression.Expression != null));
-			nodeStack.Push(unaryOperatorExpression.Expression);
-			unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-			unaryOperatorExpression.Expression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitUsing(Using @using, object data) {
-			Debug.Assert((@using != null));
-			Debug.Assert((@using.Alias != null));
-			nodeStack.Push(@using.Alias);
-			@using.Alias.AcceptVisitor(this, data);
-			@using.Alias = ((TypeReference)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
-			Debug.Assert((usingDeclaration != null));
-			Debug.Assert((usingDeclaration.Usings != null));
-			for (int i = 0; i < usingDeclaration.Usings.Count; i++) {
-				Using o = usingDeclaration.Usings[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (Using)nodeStack.Pop();
-				if (o == null)
-					usingDeclaration.Usings.RemoveAt(i--);
-				else
-					usingDeclaration.Usings[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitUsingStatement(UsingStatement usingStatement, object data) {
-			Debug.Assert((usingStatement != null));
-			Debug.Assert((usingStatement.ResourceAcquisition != null));
-			Debug.Assert((usingStatement.EmbeddedStatement != null));
-			nodeStack.Push(usingStatement.ResourceAcquisition);
-			usingStatement.ResourceAcquisition.AcceptVisitor(this, data);
-			usingStatement.ResourceAcquisition = ((Statement)(nodeStack.Pop()));
-			nodeStack.Push(usingStatement.EmbeddedStatement);
-			usingStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			usingStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
-			Debug.Assert((variableDeclaration != null));
-			Debug.Assert((variableDeclaration.Initializer != null));
-			Debug.Assert((variableDeclaration.TypeReference != null));
-			Debug.Assert((variableDeclaration.FixedArrayInitialization != null));
-			nodeStack.Push(variableDeclaration.Initializer);
-			variableDeclaration.Initializer.AcceptVisitor(this, data);
-			variableDeclaration.Initializer = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(variableDeclaration.TypeReference);
-			variableDeclaration.TypeReference.AcceptVisitor(this, data);
-			variableDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
-			nodeStack.Push(variableDeclaration.FixedArrayInitialization);
-			variableDeclaration.FixedArrayInitialization.AcceptVisitor(this, data);
-			variableDeclaration.FixedArrayInitialization = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitWithStatement(WithStatement withStatement, object data) {
-			Debug.Assert((withStatement != null));
-			Debug.Assert((withStatement.Expression != null));
-			Debug.Assert((withStatement.Body != null));
-			nodeStack.Push(withStatement.Expression);
-			withStatement.Expression.AcceptVisitor(this, data);
-			withStatement.Expression = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(withStatement.Body);
-			withStatement.Body.AcceptVisitor(this, data);
-			withStatement.Body = ((BlockStatement)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
-			Debug.Assert((xmlAttributeExpression != null));
-			Debug.Assert((xmlAttributeExpression.ExpressionValue != null));
-			nodeStack.Push(xmlAttributeExpression.ExpressionValue);
-			xmlAttributeExpression.ExpressionValue.AcceptVisitor(this, data);
-			xmlAttributeExpression.ExpressionValue = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
-			Debug.Assert((xmlContentExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
-			Debug.Assert((xmlDocumentExpression != null));
-			Debug.Assert((xmlDocumentExpression.Expressions != null));
-			for (int i = 0; i < xmlDocumentExpression.Expressions.Count; i++) {
-				XmlExpression o = xmlDocumentExpression.Expressions[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (XmlExpression)nodeStack.Pop();
-				if (o == null)
-					xmlDocumentExpression.Expressions.RemoveAt(i--);
-				else
-					xmlDocumentExpression.Expressions[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
-			Debug.Assert((xmlElementExpression != null));
-			Debug.Assert((xmlElementExpression.Content != null));
-			Debug.Assert((xmlElementExpression.NameExpression != null));
-			Debug.Assert((xmlElementExpression.Attributes != null));
-			nodeStack.Push(xmlElementExpression.Content);
-			xmlElementExpression.Content.AcceptVisitor(this, data);
-			xmlElementExpression.Content = ((Expression)(nodeStack.Pop()));
-			nodeStack.Push(xmlElementExpression.NameExpression);
-			xmlElementExpression.NameExpression.AcceptVisitor(this, data);
-			xmlElementExpression.NameExpression = ((Expression)(nodeStack.Pop()));
-			for (int i = 0; i < xmlElementExpression.Attributes.Count; i++) {
-				XmlExpression o = xmlElementExpression.Attributes[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = (XmlExpression)nodeStack.Pop();
-				if (o == null)
-					xmlElementExpression.Attributes.RemoveAt(i--);
-				else
-					xmlElementExpression.Attributes[i] = o;
-			}
-			for (int i = 0; i < xmlElementExpression.Children.Count; i++) {
-				INode o = xmlElementExpression.Children[i];
-				Debug.Assert(o != null);
-				nodeStack.Push(o);
-				o.AcceptVisitor(this, data);
-				o = nodeStack.Pop();
-				if (o == null)
-					xmlElementExpression.Children.RemoveAt(i--);
-				else
-					xmlElementExpression.Children[i] = o;
-			}
-			return null;
-		}
-		
-		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
-			Debug.Assert((xmlEmbeddedExpression != null));
-			Debug.Assert((xmlEmbeddedExpression.InlineVBExpression != null));
-			nodeStack.Push(xmlEmbeddedExpression.InlineVBExpression);
-			xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
-			xmlEmbeddedExpression.InlineVBExpression = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-		
-		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
-			Debug.Assert((xmlMemberAccessExpression != null));
-			Debug.Assert((xmlMemberAccessExpression.TargetObject != null));
-			nodeStack.Push(xmlMemberAccessExpression.TargetObject);
-			xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
-			xmlMemberAccessExpression.TargetObject = ((Expression)(nodeStack.Pop()));
-			return null;
-		}
-	}
+//	public abstract class AbstractAstTransformer : IAstVisitor {
+//		
+//		private Stack<INode> nodeStack = new Stack<INode>();
+//		
+//		public void ReplaceCurrentNode(INode newNode) {
+//			nodeStack.Pop();
+//			nodeStack.Push(newNode);
+//		}
+//		
+//		public void RemoveCurrentNode() {
+//			nodeStack.Pop();
+//			nodeStack.Push(null);
+//		}
+//		
+//		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
+//			Debug.Assert((addHandlerStatement != null));
+//			Debug.Assert((addHandlerStatement.EventExpression != null));
+//			Debug.Assert((addHandlerStatement.HandlerExpression != null));
+//			nodeStack.Push(addHandlerStatement.EventExpression);
+//			addHandlerStatement.EventExpression.AcceptVisitor(this, data);
+//			addHandlerStatement.EventExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(addHandlerStatement.HandlerExpression);
+//			addHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
+//			addHandlerStatement.HandlerExpression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
+//			Debug.Assert((addressOfExpression != null));
+//			Debug.Assert((addressOfExpression.Expression != null));
+//			nodeStack.Push(addressOfExpression.Expression);
+//			addressOfExpression.Expression.AcceptVisitor(this, data);
+//			addressOfExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
+//			Debug.Assert((arrayCreateExpression != null));
+//			Debug.Assert((arrayCreateExpression.CreateType != null));
+//			Debug.Assert((arrayCreateExpression.Arguments != null));
+//			Debug.Assert((arrayCreateExpression.ArrayInitializer != null));
+//			nodeStack.Push(arrayCreateExpression.CreateType);
+//			arrayCreateExpression.CreateType.AcceptVisitor(this, data);
+//			arrayCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop()));
+//			for (int i = 0; i < arrayCreateExpression.Arguments.Count; i++) {
+//				Expression o = arrayCreateExpression.Arguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					arrayCreateExpression.Arguments.RemoveAt(i--);
+//				else
+//					arrayCreateExpression.Arguments[i] = o;
+//			}
+//			nodeStack.Push(arrayCreateExpression.ArrayInitializer);
+//			arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
+//			arrayCreateExpression.ArrayInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
+//			Debug.Assert((assignmentExpression != null));
+//			Debug.Assert((assignmentExpression.Left != null));
+//			Debug.Assert((assignmentExpression.Right != null));
+//			nodeStack.Push(assignmentExpression.Left);
+//			assignmentExpression.Left.AcceptVisitor(this, data);
+//			assignmentExpression.Left = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(assignmentExpression.Right);
+//			assignmentExpression.Right.AcceptVisitor(this, data);
+//			assignmentExpression.Right = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
+//			Debug.Assert((attribute != null));
+//			Debug.Assert((attribute.PositionalArguments != null));
+//			Debug.Assert((attribute.NamedArguments != null));
+//			for (int i = 0; i < attribute.PositionalArguments.Count; i++) {
+//				Expression o = attribute.PositionalArguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					attribute.PositionalArguments.RemoveAt(i--);
+//				else
+//					attribute.PositionalArguments[i] = o;
+//			}
+//			for (int i = 0; i < attribute.NamedArguments.Count; i++) {
+//				NamedArgumentExpression o = attribute.NamedArguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (NamedArgumentExpression)nodeStack.Pop();
+//				if (o == null)
+//					attribute.NamedArguments.RemoveAt(i--);
+//				else
+//					attribute.NamedArguments[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitAttributeSection(AttributeSection attributeSection, object data) {
+//			Debug.Assert((attributeSection != null));
+//			Debug.Assert((attributeSection.Attributes != null));
+//			for (int i = 0; i < attributeSection.Attributes.Count; i++) {
+//				ICSharpCode.NRefactory.VB.Ast.Attribute o = attributeSection.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ICSharpCode.NRefactory.VB.Ast.Attribute)nodeStack.Pop();
+//				if (o == null)
+//					attributeSection.Attributes.RemoveAt(i--);
+//				else
+//					attributeSection.Attributes[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
+//			Debug.Assert((baseReferenceExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
+//			Debug.Assert((binaryOperatorExpression != null));
+//			Debug.Assert((binaryOperatorExpression.Left != null));
+//			Debug.Assert((binaryOperatorExpression.Right != null));
+//			nodeStack.Push(binaryOperatorExpression.Left);
+//			binaryOperatorExpression.Left.AcceptVisitor(this, data);
+//			binaryOperatorExpression.Left = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(binaryOperatorExpression.Right);
+//			binaryOperatorExpression.Right.AcceptVisitor(this, data);
+//			binaryOperatorExpression.Right = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitBlockStatement(BlockStatement blockStatement, object data) {
+//			Debug.Assert((blockStatement != null));
+//			for (int i = 0; i < blockStatement.Children.Count; i++) {
+//				INode o = blockStatement.Children[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = nodeStack.Pop();
+//				if (o == null)
+//					blockStatement.Children.RemoveAt(i--);
+//				else
+//					blockStatement.Children[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitCaseLabel(CaseLabel caseLabel, object data) {
+//			Debug.Assert((caseLabel != null));
+//			Debug.Assert((caseLabel.Label != null));
+//			Debug.Assert((caseLabel.ToExpression != null));
+//			nodeStack.Push(caseLabel.Label);
+//			caseLabel.Label.AcceptVisitor(this, data);
+//			caseLabel.Label = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(caseLabel.ToExpression);
+//			caseLabel.ToExpression.AcceptVisitor(this, data);
+//			caseLabel.ToExpression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitCastExpression(CastExpression castExpression, object data) {
+//			Debug.Assert((castExpression != null));
+//			Debug.Assert((castExpression.CastTo != null));
+//			Debug.Assert((castExpression.Expression != null));
+//			nodeStack.Push(castExpression.CastTo);
+//			castExpression.CastTo.AcceptVisitor(this, data);
+//			castExpression.CastTo = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(castExpression.Expression);
+//			castExpression.Expression.AcceptVisitor(this, data);
+//			castExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitCatchClause(CatchClause catchClause, object data) {
+//			Debug.Assert((catchClause != null));
+//			Debug.Assert((catchClause.TypeReference != null));
+//			Debug.Assert((catchClause.StatementBlock != null));
+//			Debug.Assert((catchClause.Condition != null));
+//			nodeStack.Push(catchClause.TypeReference);
+//			catchClause.TypeReference.AcceptVisitor(this, data);
+//			catchClause.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(catchClause.StatementBlock);
+//			catchClause.StatementBlock.AcceptVisitor(this, data);
+//			catchClause.StatementBlock = ((Statement)(nodeStack.Pop()));
+//			nodeStack.Push(catchClause.Condition);
+//			catchClause.Condition.AcceptVisitor(this, data);
+//			catchClause.Condition = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
+//			Debug.Assert((classReferenceExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
+//			Debug.Assert((collectionInitializerExpression != null));
+//			Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
+//			for (int i = 0; i < collectionInitializerExpression.CreateExpressions.Count; i++) {
+//				Expression o = collectionInitializerExpression.CreateExpressions[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					collectionInitializerExpression.CreateExpressions.RemoveAt(i--);
+//				else
+//					collectionInitializerExpression.CreateExpressions[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
+//			Debug.Assert((collectionRangeVariable != null));
+//			Debug.Assert((collectionRangeVariable.Expression != null));
+//			Debug.Assert((collectionRangeVariable.Type != null));
+//			nodeStack.Push(collectionRangeVariable.Expression);
+//			collectionRangeVariable.Expression.AcceptVisitor(this, data);
+//			collectionRangeVariable.Expression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(collectionRangeVariable.Type);
+//			collectionRangeVariable.Type.AcceptVisitor(this, data);
+//			collectionRangeVariable.Type = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
+//			Debug.Assert((compilationUnit != null));
+//			for (int i = 0; i < compilationUnit.Children.Count; i++) {
+//				INode o = compilationUnit.Children[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = nodeStack.Pop();
+//				if (o == null)
+//					compilationUnit.Children.RemoveAt(i--);
+//				else
+//					compilationUnit.Children[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
+//			Debug.Assert((conditionalExpression != null));
+//			Debug.Assert((conditionalExpression.Condition != null));
+//			Debug.Assert((conditionalExpression.TrueExpression != null));
+//			Debug.Assert((conditionalExpression.FalseExpression != null));
+//			nodeStack.Push(conditionalExpression.Condition);
+//			conditionalExpression.Condition.AcceptVisitor(this, data);
+//			conditionalExpression.Condition = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(conditionalExpression.TrueExpression);
+//			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
+//			conditionalExpression.TrueExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(conditionalExpression.FalseExpression);
+//			conditionalExpression.FalseExpression.AcceptVisitor(this, data);
+//			conditionalExpression.FalseExpression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
+//			Debug.Assert((constructorDeclaration != null));
+//			Debug.Assert((constructorDeclaration.Attributes != null));
+//			Debug.Assert((constructorDeclaration.Parameters != null));
+//			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
+//			Debug.Assert((constructorDeclaration.Body != null));
+//			for (int i = 0; i < constructorDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = constructorDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					constructorDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					constructorDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < constructorDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = constructorDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					constructorDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					constructorDeclaration.Parameters[i] = o;
+//			}
+//			nodeStack.Push(constructorDeclaration.ConstructorInitializer);
+//			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
+//			constructorDeclaration.ConstructorInitializer = ((ConstructorInitializer)(nodeStack.Pop()));
+//			nodeStack.Push(constructorDeclaration.Body);
+//			constructorDeclaration.Body.AcceptVisitor(this, data);
+//			constructorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
+//			Debug.Assert((constructorInitializer != null));
+//			Debug.Assert((constructorInitializer.Arguments != null));
+//			for (int i = 0; i < constructorInitializer.Arguments.Count; i++) {
+//				Expression o = constructorInitializer.Arguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					constructorInitializer.Arguments.RemoveAt(i--);
+//				else
+//					constructorInitializer.Arguments[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitContinueStatement(ContinueStatement continueStatement, object data) {
+//			Debug.Assert((continueStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
+//			Debug.Assert((declareDeclaration != null));
+//			Debug.Assert((declareDeclaration.Attributes != null));
+//			Debug.Assert((declareDeclaration.Parameters != null));
+//			Debug.Assert((declareDeclaration.TypeReference != null));
+//			for (int i = 0; i < declareDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = declareDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					declareDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					declareDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < declareDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = declareDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					declareDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					declareDeclaration.Parameters[i] = o;
+//			}
+//			nodeStack.Push(declareDeclaration.TypeReference);
+//			declareDeclaration.TypeReference.AcceptVisitor(this, data);
+//			declareDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
+//			Debug.Assert((defaultValueExpression != null));
+//			Debug.Assert((defaultValueExpression.TypeReference != null));
+//			nodeStack.Push(defaultValueExpression.TypeReference);
+//			defaultValueExpression.TypeReference.AcceptVisitor(this, data);
+//			defaultValueExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
+//			Debug.Assert((delegateDeclaration != null));
+//			Debug.Assert((delegateDeclaration.Attributes != null));
+//			Debug.Assert((delegateDeclaration.ReturnType != null));
+//			Debug.Assert((delegateDeclaration.Parameters != null));
+//			Debug.Assert((delegateDeclaration.Templates != null));
+//			for (int i = 0; i < delegateDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = delegateDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					delegateDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					delegateDeclaration.Attributes[i] = o;
+//			}
+//			nodeStack.Push(delegateDeclaration.ReturnType);
+//			delegateDeclaration.ReturnType.AcceptVisitor(this, data);
+//			delegateDeclaration.ReturnType = ((TypeReference)(nodeStack.Pop()));
+//			for (int i = 0; i < delegateDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = delegateDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					delegateDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					delegateDeclaration.Parameters[i] = o;
+//			}
+//			for (int i = 0; i < delegateDeclaration.Templates.Count; i++) {
+//				TemplateDefinition o = delegateDeclaration.Templates[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TemplateDefinition)nodeStack.Pop();
+//				if (o == null)
+//					delegateDeclaration.Templates.RemoveAt(i--);
+//				else
+//					delegateDeclaration.Templates[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
+//			Debug.Assert((directionExpression != null));
+//			Debug.Assert((directionExpression.Expression != null));
+//			nodeStack.Push(directionExpression.Expression);
+//			directionExpression.Expression.AcceptVisitor(this, data);
+//			directionExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
+//			Debug.Assert((doLoopStatement != null));
+//			Debug.Assert((doLoopStatement.Condition != null));
+//			Debug.Assert((doLoopStatement.EmbeddedStatement != null));
+//			nodeStack.Push(doLoopStatement.Condition);
+//			doLoopStatement.Condition.AcceptVisitor(this, data);
+//			doLoopStatement.Condition = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(doLoopStatement.EmbeddedStatement);
+//			doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//			doLoopStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
+//			Debug.Assert((elseIfSection != null));
+//			Debug.Assert((elseIfSection.Condition != null));
+//			Debug.Assert((elseIfSection.EmbeddedStatement != null));
+//			nodeStack.Push(elseIfSection.Condition);
+//			elseIfSection.Condition.AcceptVisitor(this, data);
+//			elseIfSection.Condition = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(elseIfSection.EmbeddedStatement);
+//			elseIfSection.EmbeddedStatement.AcceptVisitor(this, data);
+//			elseIfSection.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitEndStatement(EndStatement endStatement, object data) {
+//			Debug.Assert((endStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitEraseStatement(EraseStatement eraseStatement, object data) {
+//			Debug.Assert((eraseStatement != null));
+//			Debug.Assert((eraseStatement.Expressions != null));
+//			for (int i = 0; i < eraseStatement.Expressions.Count; i++) {
+//				Expression o = eraseStatement.Expressions[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					eraseStatement.Expressions.RemoveAt(i--);
+//				else
+//					eraseStatement.Expressions[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitErrorStatement(ErrorStatement errorStatement, object data) {
+//			Debug.Assert((errorStatement != null));
+//			Debug.Assert((errorStatement.Expression != null));
+//			nodeStack.Push(errorStatement.Expression);
+//			errorStatement.Expression.AcceptVisitor(this, data);
+//			errorStatement.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
+//			Debug.Assert((eventAddRegion != null));
+//			Debug.Assert((eventAddRegion.Attributes != null));
+//			Debug.Assert((eventAddRegion.Block != null));
+//			Debug.Assert((eventAddRegion.Parameters != null));
+//			for (int i = 0; i < eventAddRegion.Attributes.Count; i++) {
+//				AttributeSection o = eventAddRegion.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					eventAddRegion.Attributes.RemoveAt(i--);
+//				else
+//					eventAddRegion.Attributes[i] = o;
+//			}
+//			nodeStack.Push(eventAddRegion.Block);
+//			eventAddRegion.Block.AcceptVisitor(this, data);
+//			eventAddRegion.Block = ((BlockStatement)(nodeStack.Pop()));
+//			for (int i = 0; i < eventAddRegion.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = eventAddRegion.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					eventAddRegion.Parameters.RemoveAt(i--);
+//				else
+//					eventAddRegion.Parameters[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
+//			Debug.Assert((eventDeclaration != null));
+//			Debug.Assert((eventDeclaration.Attributes != null));
+//			Debug.Assert((eventDeclaration.Parameters != null));
+//			Debug.Assert((eventDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((eventDeclaration.TypeReference != null));
+//			Debug.Assert((eventDeclaration.AddRegion != null));
+//			Debug.Assert((eventDeclaration.RemoveRegion != null));
+//			Debug.Assert((eventDeclaration.RaiseRegion != null));
+//			Debug.Assert((eventDeclaration.Initializer != null));
+//			for (int i = 0; i < eventDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = eventDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					eventDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					eventDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < eventDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = eventDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					eventDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					eventDeclaration.Parameters[i] = o;
+//			}
+//			for (int i = 0; i < eventDeclaration.InterfaceImplementations.Count; i++) {
+//				InterfaceImplementation o = eventDeclaration.InterfaceImplementations[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (InterfaceImplementation)nodeStack.Pop();
+//				if (o == null)
+//					eventDeclaration.InterfaceImplementations.RemoveAt(i--);
+//				else
+//					eventDeclaration.InterfaceImplementations[i] = o;
+//			}
+//			nodeStack.Push(eventDeclaration.TypeReference);
+//			eventDeclaration.TypeReference.AcceptVisitor(this, data);
+//			eventDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(eventDeclaration.AddRegion);
+//			eventDeclaration.AddRegion.AcceptVisitor(this, data);
+//			eventDeclaration.AddRegion = ((EventAddRegion)(nodeStack.Pop()));
+//			nodeStack.Push(eventDeclaration.RemoveRegion);
+//			eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
+//			eventDeclaration.RemoveRegion = ((EventRemoveRegion)(nodeStack.Pop()));
+//			nodeStack.Push(eventDeclaration.RaiseRegion);
+//			eventDeclaration.RaiseRegion.AcceptVisitor(this, data);
+//			eventDeclaration.RaiseRegion = ((EventRaiseRegion)(nodeStack.Pop()));
+//			nodeStack.Push(eventDeclaration.Initializer);
+//			eventDeclaration.Initializer.AcceptVisitor(this, data);
+//			eventDeclaration.Initializer = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
+//			Debug.Assert((eventRaiseRegion != null));
+//			Debug.Assert((eventRaiseRegion.Attributes != null));
+//			Debug.Assert((eventRaiseRegion.Block != null));
+//			Debug.Assert((eventRaiseRegion.Parameters != null));
+//			for (int i = 0; i < eventRaiseRegion.Attributes.Count; i++) {
+//				AttributeSection o = eventRaiseRegion.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					eventRaiseRegion.Attributes.RemoveAt(i--);
+//				else
+//					eventRaiseRegion.Attributes[i] = o;
+//			}
+//			nodeStack.Push(eventRaiseRegion.Block);
+//			eventRaiseRegion.Block.AcceptVisitor(this, data);
+//			eventRaiseRegion.Block = ((BlockStatement)(nodeStack.Pop()));
+//			for (int i = 0; i < eventRaiseRegion.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = eventRaiseRegion.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					eventRaiseRegion.Parameters.RemoveAt(i--);
+//				else
+//					eventRaiseRegion.Parameters[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
+//			Debug.Assert((eventRemoveRegion != null));
+//			Debug.Assert((eventRemoveRegion.Attributes != null));
+//			Debug.Assert((eventRemoveRegion.Block != null));
+//			Debug.Assert((eventRemoveRegion.Parameters != null));
+//			for (int i = 0; i < eventRemoveRegion.Attributes.Count; i++) {
+//				AttributeSection o = eventRemoveRegion.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					eventRemoveRegion.Attributes.RemoveAt(i--);
+//				else
+//					eventRemoveRegion.Attributes[i] = o;
+//			}
+//			nodeStack.Push(eventRemoveRegion.Block);
+//			eventRemoveRegion.Block.AcceptVisitor(this, data);
+//			eventRemoveRegion.Block = ((BlockStatement)(nodeStack.Pop()));
+//			for (int i = 0; i < eventRemoveRegion.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = eventRemoveRegion.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					eventRemoveRegion.Parameters.RemoveAt(i--);
+//				else
+//					eventRemoveRegion.Parameters[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitExitStatement(ExitStatement exitStatement, object data) {
+//			Debug.Assert((exitStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
+//			Debug.Assert((expressionRangeVariable != null));
+//			Debug.Assert((expressionRangeVariable.Expression != null));
+//			Debug.Assert((expressionRangeVariable.Type != null));
+//			nodeStack.Push(expressionRangeVariable.Expression);
+//			expressionRangeVariable.Expression.AcceptVisitor(this, data);
+//			expressionRangeVariable.Expression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(expressionRangeVariable.Type);
+//			expressionRangeVariable.Type.AcceptVisitor(this, data);
+//			expressionRangeVariable.Type = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
+//			Debug.Assert((expressionStatement != null));
+//			Debug.Assert((expressionStatement.Expression != null));
+//			nodeStack.Push(expressionStatement.Expression);
+//			expressionStatement.Expression.AcceptVisitor(this, data);
+//			expressionStatement.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
+//			Debug.Assert((externAliasDirective != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
+//			Debug.Assert((fieldDeclaration != null));
+//			Debug.Assert((fieldDeclaration.Attributes != null));
+//			Debug.Assert((fieldDeclaration.TypeReference != null));
+//			Debug.Assert((fieldDeclaration.Fields != null));
+//			for (int i = 0; i < fieldDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = fieldDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					fieldDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					fieldDeclaration.Attributes[i] = o;
+//			}
+//			nodeStack.Push(fieldDeclaration.TypeReference);
+//			fieldDeclaration.TypeReference.AcceptVisitor(this, data);
+//			fieldDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			for (int i = 0; i < fieldDeclaration.Fields.Count; i++) {
+//				VariableDeclaration o = fieldDeclaration.Fields[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (VariableDeclaration)nodeStack.Pop();
+//				if (o == null)
+//					fieldDeclaration.Fields.RemoveAt(i--);
+//				else
+//					fieldDeclaration.Fields[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
+//			Debug.Assert((foreachStatement != null));
+//			Debug.Assert((foreachStatement.TypeReference != null));
+//			Debug.Assert((foreachStatement.Expression != null));
+//			Debug.Assert((foreachStatement.NextExpression != null));
+//			Debug.Assert((foreachStatement.EmbeddedStatement != null));
+//			nodeStack.Push(foreachStatement.TypeReference);
+//			foreachStatement.TypeReference.AcceptVisitor(this, data);
+//			foreachStatement.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(foreachStatement.Expression);
+//			foreachStatement.Expression.AcceptVisitor(this, data);
+//			foreachStatement.Expression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(foreachStatement.NextExpression);
+//			foreachStatement.NextExpression.AcceptVisitor(this, data);
+//			foreachStatement.NextExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(foreachStatement.EmbeddedStatement);
+//			foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//			foreachStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
+//			Debug.Assert((forNextStatement != null));
+//			Debug.Assert((forNextStatement.Start != null));
+//			Debug.Assert((forNextStatement.End != null));
+//			Debug.Assert((forNextStatement.Step != null));
+//			Debug.Assert((forNextStatement.NextExpressions != null));
+//			Debug.Assert((forNextStatement.TypeReference != null));
+//			Debug.Assert((forNextStatement.LoopVariableExpression != null));
+//			Debug.Assert((forNextStatement.EmbeddedStatement != null));
+//			nodeStack.Push(forNextStatement.Start);
+//			forNextStatement.Start.AcceptVisitor(this, data);
+//			forNextStatement.Start = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(forNextStatement.End);
+//			forNextStatement.End.AcceptVisitor(this, data);
+//			forNextStatement.End = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(forNextStatement.Step);
+//			forNextStatement.Step.AcceptVisitor(this, data);
+//			forNextStatement.Step = ((Expression)(nodeStack.Pop()));
+//			for (int i = 0; i < forNextStatement.NextExpressions.Count; i++) {
+//				Expression o = forNextStatement.NextExpressions[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					forNextStatement.NextExpressions.RemoveAt(i--);
+//				else
+//					forNextStatement.NextExpressions[i] = o;
+//			}
+//			nodeStack.Push(forNextStatement.TypeReference);
+//			forNextStatement.TypeReference.AcceptVisitor(this, data);
+//			forNextStatement.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(forNextStatement.LoopVariableExpression);
+//			forNextStatement.LoopVariableExpression.AcceptVisitor(this, data);
+//			forNextStatement.LoopVariableExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(forNextStatement.EmbeddedStatement);
+//			forNextStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//			forNextStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitGotoStatement(GotoStatement gotoStatement, object data) {
+//			Debug.Assert((gotoStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitIdentifierExpression(SimpleNameExpression identifierExpression, object data) {
+//			Debug.Assert((identifierExpression != null));
+//			Debug.Assert((identifierExpression.TypeArguments != null));
+//			for (int i = 0; i < identifierExpression.TypeArguments.Count; i++) {
+//				TypeReference o = identifierExpression.TypeArguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TypeReference)nodeStack.Pop();
+//				if (o == null)
+//					identifierExpression.TypeArguments.RemoveAt(i--);
+//				else
+//					identifierExpression.TypeArguments[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
+//			Debug.Assert((ifElseStatement != null));
+//			Debug.Assert((ifElseStatement.Condition != null));
+//			Debug.Assert((ifElseStatement.TrueStatement != null));
+//			Debug.Assert((ifElseStatement.FalseStatement != null));
+//			Debug.Assert((ifElseStatement.ElseIfSections != null));
+//			nodeStack.Push(ifElseStatement.Condition);
+//			ifElseStatement.Condition.AcceptVisitor(this, data);
+//			ifElseStatement.Condition = ((Expression)(nodeStack.Pop()));
+//			for (int i = 0; i < ifElseStatement.TrueStatement.Count; i++) {
+//				Statement o = ifElseStatement.TrueStatement[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Statement)nodeStack.Pop();
+//				if (o == null)
+//					ifElseStatement.TrueStatement.RemoveAt(i--);
+//				else
+//					ifElseStatement.TrueStatement[i] = o;
+//			}
+//			for (int i = 0; i < ifElseStatement.FalseStatement.Count; i++) {
+//				Statement o = ifElseStatement.FalseStatement[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Statement)nodeStack.Pop();
+//				if (o == null)
+//					ifElseStatement.FalseStatement.RemoveAt(i--);
+//				else
+//					ifElseStatement.FalseStatement[i] = o;
+//			}
+//			for (int i = 0; i < ifElseStatement.ElseIfSections.Count; i++) {
+//				ElseIfSection o = ifElseStatement.ElseIfSections[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ElseIfSection)nodeStack.Pop();
+//				if (o == null)
+//					ifElseStatement.ElseIfSections.RemoveAt(i--);
+//				else
+//					ifElseStatement.ElseIfSections[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
+//			Debug.Assert((innerClassTypeReference != null));
+//			Debug.Assert((innerClassTypeReference.GenericTypes != null));
+//			Debug.Assert((innerClassTypeReference.BaseType != null));
+//			for (int i = 0; i < innerClassTypeReference.GenericTypes.Count; i++) {
+//				TypeReference o = innerClassTypeReference.GenericTypes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TypeReference)nodeStack.Pop();
+//				if (o == null)
+//					innerClassTypeReference.GenericTypes.RemoveAt(i--);
+//				else
+//					innerClassTypeReference.GenericTypes[i] = o;
+//			}
+//			nodeStack.Push(innerClassTypeReference.BaseType);
+//			innerClassTypeReference.BaseType.AcceptVisitor(this, data);
+//			innerClassTypeReference.BaseType = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
+//			Debug.Assert((interfaceImplementation != null));
+//			Debug.Assert((interfaceImplementation.InterfaceType != null));
+//			nodeStack.Push(interfaceImplementation.InterfaceType);
+//			interfaceImplementation.InterfaceType.AcceptVisitor(this, data);
+//			interfaceImplementation.InterfaceType = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
+//			Debug.Assert((invocationExpression != null));
+//			Debug.Assert((invocationExpression.TargetObject != null));
+//			Debug.Assert((invocationExpression.Arguments != null));
+//			nodeStack.Push(invocationExpression.TargetObject);
+//			invocationExpression.TargetObject.AcceptVisitor(this, data);
+//			invocationExpression.TargetObject = ((Expression)(nodeStack.Pop()));
+//			for (int i = 0; i < invocationExpression.Arguments.Count; i++) {
+//				Expression o = invocationExpression.Arguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					invocationExpression.Arguments.RemoveAt(i--);
+//				else
+//					invocationExpression.Arguments[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitLabelStatement(LabelStatement labelStatement, object data) {
+//			Debug.Assert((labelStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
+//			Debug.Assert((lambdaExpression != null));
+//			Debug.Assert((lambdaExpression.Parameters != null));
+//			Debug.Assert((lambdaExpression.StatementBody != null));
+//			Debug.Assert((lambdaExpression.ExpressionBody != null));
+//			Debug.Assert((lambdaExpression.ReturnType != null));
+//			for (int i = 0; i < lambdaExpression.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = lambdaExpression.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					lambdaExpression.Parameters.RemoveAt(i--);
+//				else
+//					lambdaExpression.Parameters[i] = o;
+//			}
+//			nodeStack.Push(lambdaExpression.StatementBody);
+//			lambdaExpression.StatementBody.AcceptVisitor(this, data);
+//			lambdaExpression.StatementBody = ((Statement)(nodeStack.Pop()));
+//			nodeStack.Push(lambdaExpression.ExpressionBody);
+//			lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
+//			lambdaExpression.ExpressionBody = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(lambdaExpression.ReturnType);
+//			lambdaExpression.ReturnType.AcceptVisitor(this, data);
+//			lambdaExpression.ReturnType = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
+//			Debug.Assert((localVariableDeclaration != null));
+//			Debug.Assert((localVariableDeclaration.TypeReference != null));
+//			Debug.Assert((localVariableDeclaration.Variables != null));
+//			nodeStack.Push(localVariableDeclaration.TypeReference);
+//			localVariableDeclaration.TypeReference.AcceptVisitor(this, data);
+//			localVariableDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			for (int i = 0; i < localVariableDeclaration.Variables.Count; i++) {
+//				VariableDeclaration o = localVariableDeclaration.Variables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (VariableDeclaration)nodeStack.Pop();
+//				if (o == null)
+//					localVariableDeclaration.Variables.RemoveAt(i--);
+//				else
+//					localVariableDeclaration.Variables[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitLockStatement(LockStatement lockStatement, object data) {
+//			Debug.Assert((lockStatement != null));
+//			Debug.Assert((lockStatement.LockExpression != null));
+//			Debug.Assert((lockStatement.EmbeddedStatement != null));
+//			nodeStack.Push(lockStatement.LockExpression);
+//			lockStatement.LockExpression.AcceptVisitor(this, data);
+//			lockStatement.LockExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(lockStatement.EmbeddedStatement);
+//			lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//			lockStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
+//			Debug.Assert((memberInitializerExpression != null));
+//			Debug.Assert((memberInitializerExpression.Expression != null));
+//			nodeStack.Push(memberInitializerExpression.Expression);
+//			memberInitializerExpression.Expression.AcceptVisitor(this, data);
+//			memberInitializerExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
+//			Debug.Assert((memberReferenceExpression != null));
+//			Debug.Assert((memberReferenceExpression.TargetObject != null));
+//			Debug.Assert((memberReferenceExpression.TypeArguments != null));
+//			nodeStack.Push(memberReferenceExpression.TargetObject);
+//			memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
+//			memberReferenceExpression.TargetObject = ((Expression)(nodeStack.Pop()));
+//			for (int i = 0; i < memberReferenceExpression.TypeArguments.Count; i++) {
+//				TypeReference o = memberReferenceExpression.TypeArguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TypeReference)nodeStack.Pop();
+//				if (o == null)
+//					memberReferenceExpression.TypeArguments.RemoveAt(i--);
+//				else
+//					memberReferenceExpression.TypeArguments[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
+//			Debug.Assert((methodDeclaration != null));
+//			Debug.Assert((methodDeclaration.Attributes != null));
+//			Debug.Assert((methodDeclaration.Parameters != null));
+//			Debug.Assert((methodDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((methodDeclaration.TypeReference != null));
+//			Debug.Assert((methodDeclaration.Body != null));
+//			Debug.Assert((methodDeclaration.Templates != null));
+//			for (int i = 0; i < methodDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = methodDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					methodDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					methodDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < methodDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = methodDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					methodDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					methodDeclaration.Parameters[i] = o;
+//			}
+//			for (int i = 0; i < methodDeclaration.InterfaceImplementations.Count; i++) {
+//				InterfaceImplementation o = methodDeclaration.InterfaceImplementations[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (InterfaceImplementation)nodeStack.Pop();
+//				if (o == null)
+//					methodDeclaration.InterfaceImplementations.RemoveAt(i--);
+//				else
+//					methodDeclaration.InterfaceImplementations[i] = o;
+//			}
+//			nodeStack.Push(methodDeclaration.TypeReference);
+//			methodDeclaration.TypeReference.AcceptVisitor(this, data);
+//			methodDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(methodDeclaration.Body);
+//			methodDeclaration.Body.AcceptVisitor(this, data);
+//			methodDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
+//			for (int i = 0; i < methodDeclaration.Templates.Count; i++) {
+//				TemplateDefinition o = methodDeclaration.Templates[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TemplateDefinition)nodeStack.Pop();
+//				if (o == null)
+//					methodDeclaration.Templates.RemoveAt(i--);
+//				else
+//					methodDeclaration.Templates[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
+//			Debug.Assert((namedArgumentExpression != null));
+//			Debug.Assert((namedArgumentExpression.Expression != null));
+//			nodeStack.Push(namedArgumentExpression.Expression);
+//			namedArgumentExpression.Expression.AcceptVisitor(this, data);
+//			namedArgumentExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
+//			Debug.Assert((namespaceDeclaration != null));
+//			for (int i = 0; i < namespaceDeclaration.Children.Count; i++) {
+//				INode o = namespaceDeclaration.Children[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = nodeStack.Pop();
+//				if (o == null)
+//					namespaceDeclaration.Children.RemoveAt(i--);
+//				else
+//					namespaceDeclaration.Children[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
+//			Debug.Assert((objectCreateExpression != null));
+//			Debug.Assert((objectCreateExpression.CreateType != null));
+//			Debug.Assert((objectCreateExpression.Parameters != null));
+//			Debug.Assert((objectCreateExpression.ObjectInitializer != null));
+//			nodeStack.Push(objectCreateExpression.CreateType);
+//			objectCreateExpression.CreateType.AcceptVisitor(this, data);
+//			objectCreateExpression.CreateType = ((TypeReference)(nodeStack.Pop()));
+//			for (int i = 0; i < objectCreateExpression.Parameters.Count; i++) {
+//				Expression o = objectCreateExpression.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					objectCreateExpression.Parameters.RemoveAt(i--);
+//				else
+//					objectCreateExpression.Parameters[i] = o;
+//			}
+//			nodeStack.Push(objectCreateExpression.ObjectInitializer);
+//			objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
+//			objectCreateExpression.ObjectInitializer = ((CollectionInitializerExpression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
+//			Debug.Assert((onErrorStatement != null));
+//			Debug.Assert((onErrorStatement.EmbeddedStatement != null));
+//			nodeStack.Push(onErrorStatement.EmbeddedStatement);
+//			onErrorStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//			onErrorStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
+//			Debug.Assert((operatorDeclaration != null));
+//			Debug.Assert((operatorDeclaration.Attributes != null));
+//			Debug.Assert((operatorDeclaration.Parameters != null));
+//			Debug.Assert((operatorDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((operatorDeclaration.TypeReference != null));
+//			Debug.Assert((operatorDeclaration.Body != null));
+//			Debug.Assert((operatorDeclaration.Templates != null));
+//			for (int i = 0; i < operatorDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = operatorDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					operatorDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					operatorDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < operatorDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = operatorDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					operatorDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					operatorDeclaration.Parameters[i] = o;
+//			}
+//			for (int i = 0; i < operatorDeclaration.InterfaceImplementations.Count; i++) {
+//				InterfaceImplementation o = operatorDeclaration.InterfaceImplementations[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (InterfaceImplementation)nodeStack.Pop();
+//				if (o == null)
+//					operatorDeclaration.InterfaceImplementations.RemoveAt(i--);
+//				else
+//					operatorDeclaration.InterfaceImplementations[i] = o;
+//			}
+//			nodeStack.Push(operatorDeclaration.TypeReference);
+//			operatorDeclaration.TypeReference.AcceptVisitor(this, data);
+//			operatorDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(operatorDeclaration.Body);
+//			operatorDeclaration.Body.AcceptVisitor(this, data);
+//			operatorDeclaration.Body = ((BlockStatement)(nodeStack.Pop()));
+//			for (int i = 0; i < operatorDeclaration.Templates.Count; i++) {
+//				TemplateDefinition o = operatorDeclaration.Templates[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TemplateDefinition)nodeStack.Pop();
+//				if (o == null)
+//					operatorDeclaration.Templates.RemoveAt(i--);
+//				else
+//					operatorDeclaration.Templates[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
+//			Debug.Assert((optionDeclaration != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
+//			Debug.Assert((parameterDeclarationExpression != null));
+//			Debug.Assert((parameterDeclarationExpression.Attributes != null));
+//			Debug.Assert((parameterDeclarationExpression.TypeReference != null));
+//			Debug.Assert((parameterDeclarationExpression.DefaultValue != null));
+//			for (int i = 0; i < parameterDeclarationExpression.Attributes.Count; i++) {
+//				AttributeSection o = parameterDeclarationExpression.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					parameterDeclarationExpression.Attributes.RemoveAt(i--);
+//				else
+//					parameterDeclarationExpression.Attributes[i] = o;
+//			}
+//			nodeStack.Push(parameterDeclarationExpression.TypeReference);
+//			parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data);
+//			parameterDeclarationExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(parameterDeclarationExpression.DefaultValue);
+//			parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data);
+//			parameterDeclarationExpression.DefaultValue = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
+//			Debug.Assert((parenthesizedExpression != null));
+//			Debug.Assert((parenthesizedExpression.Expression != null));
+//			nodeStack.Push(parenthesizedExpression.Expression);
+//			parenthesizedExpression.Expression.AcceptVisitor(this, data);
+//			parenthesizedExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
+//			Debug.Assert((primitiveExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
+//			Debug.Assert((propertyDeclaration != null));
+//			Debug.Assert((propertyDeclaration.Attributes != null));
+//			Debug.Assert((propertyDeclaration.Parameters != null));
+//			Debug.Assert((propertyDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((propertyDeclaration.TypeReference != null));
+//			Debug.Assert((propertyDeclaration.GetRegion != null));
+//			Debug.Assert((propertyDeclaration.SetRegion != null));
+//			Debug.Assert((propertyDeclaration.Initializer != null));
+//			for (int i = 0; i < propertyDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = propertyDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					propertyDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					propertyDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < propertyDeclaration.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = propertyDeclaration.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					propertyDeclaration.Parameters.RemoveAt(i--);
+//				else
+//					propertyDeclaration.Parameters[i] = o;
+//			}
+//			for (int i = 0; i < propertyDeclaration.InterfaceImplementations.Count; i++) {
+//				InterfaceImplementation o = propertyDeclaration.InterfaceImplementations[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (InterfaceImplementation)nodeStack.Pop();
+//				if (o == null)
+//					propertyDeclaration.InterfaceImplementations.RemoveAt(i--);
+//				else
+//					propertyDeclaration.InterfaceImplementations[i] = o;
+//			}
+//			nodeStack.Push(propertyDeclaration.TypeReference);
+//			propertyDeclaration.TypeReference.AcceptVisitor(this, data);
+//			propertyDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(propertyDeclaration.GetRegion);
+//			propertyDeclaration.GetRegion.AcceptVisitor(this, data);
+//			propertyDeclaration.GetRegion = ((PropertyGetRegion)(nodeStack.Pop()));
+//			nodeStack.Push(propertyDeclaration.SetRegion);
+//			propertyDeclaration.SetRegion.AcceptVisitor(this, data);
+//			propertyDeclaration.SetRegion = ((PropertySetRegion)(nodeStack.Pop()));
+//			nodeStack.Push(propertyDeclaration.Initializer);
+//			propertyDeclaration.Initializer.AcceptVisitor(this, data);
+//			propertyDeclaration.Initializer = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
+//			Debug.Assert((propertyGetRegion != null));
+//			Debug.Assert((propertyGetRegion.Attributes != null));
+//			Debug.Assert((propertyGetRegion.Block != null));
+//			for (int i = 0; i < propertyGetRegion.Attributes.Count; i++) {
+//				AttributeSection o = propertyGetRegion.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					propertyGetRegion.Attributes.RemoveAt(i--);
+//				else
+//					propertyGetRegion.Attributes[i] = o;
+//			}
+//			nodeStack.Push(propertyGetRegion.Block);
+//			propertyGetRegion.Block.AcceptVisitor(this, data);
+//			propertyGetRegion.Block = ((BlockStatement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
+//			Debug.Assert((propertySetRegion != null));
+//			Debug.Assert((propertySetRegion.Attributes != null));
+//			Debug.Assert((propertySetRegion.Block != null));
+//			Debug.Assert((propertySetRegion.Parameters != null));
+//			for (int i = 0; i < propertySetRegion.Attributes.Count; i++) {
+//				AttributeSection o = propertySetRegion.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					propertySetRegion.Attributes.RemoveAt(i--);
+//				else
+//					propertySetRegion.Attributes[i] = o;
+//			}
+//			nodeStack.Push(propertySetRegion.Block);
+//			propertySetRegion.Block.AcceptVisitor(this, data);
+//			propertySetRegion.Block = ((BlockStatement)(nodeStack.Pop()));
+//			for (int i = 0; i < propertySetRegion.Parameters.Count; i++) {
+//				ParameterDeclarationExpression o = propertySetRegion.Parameters[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ParameterDeclarationExpression)nodeStack.Pop();
+//				if (o == null)
+//					propertySetRegion.Parameters.RemoveAt(i--);
+//				else
+//					propertySetRegion.Parameters[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
+//			Debug.Assert((queryExpression != null));
+//			Debug.Assert((queryExpression.Clauses != null));
+//			for (int i = 0; i < queryExpression.Clauses.Count; i++) {
+//				QueryExpressionClause o = queryExpression.Clauses[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (QueryExpressionClause)nodeStack.Pop();
+//				if (o == null)
+//					queryExpression.Clauses.RemoveAt(i--);
+//				else
+//					queryExpression.Clauses[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
+//			Debug.Assert((queryExpressionAggregateClause != null));
+//			Debug.Assert((queryExpressionAggregateClause.Source != null));
+//			Debug.Assert((queryExpressionAggregateClause.MiddleClauses != null));
+//			Debug.Assert((queryExpressionAggregateClause.IntoVariables != null));
+//			nodeStack.Push(queryExpressionAggregateClause.Source);
+//			queryExpressionAggregateClause.Source.AcceptVisitor(this, data);
+//			queryExpressionAggregateClause.Source = ((CollectionRangeVariable)(nodeStack.Pop()));
+//			for (int i = 0; i < queryExpressionAggregateClause.MiddleClauses.Count; i++) {
+//				QueryExpressionClause o = queryExpressionAggregateClause.MiddleClauses[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (QueryExpressionClause)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionAggregateClause.MiddleClauses.RemoveAt(i--);
+//				else
+//					queryExpressionAggregateClause.MiddleClauses[i] = o;
+//			}
+//			for (int i = 0; i < queryExpressionAggregateClause.IntoVariables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionAggregateClause.IntoVariables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionAggregateClause.IntoVariables.RemoveAt(i--);
+//				else
+//					queryExpressionAggregateClause.IntoVariables[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
+//			Debug.Assert((queryExpressionDistinctClause != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
+//			Debug.Assert((queryExpressionFromClause != null));
+//			Debug.Assert((queryExpressionFromClause.Sources != null));
+//			for (int i = 0; i < queryExpressionFromClause.Sources.Count; i++) {
+//				CollectionRangeVariable o = queryExpressionFromClause.Sources[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (CollectionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionFromClause.Sources.RemoveAt(i--);
+//				else
+//					queryExpressionFromClause.Sources[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
+//			Debug.Assert((queryExpressionGroupClause != null));
+//			Debug.Assert((queryExpressionGroupClause.Projection != null));
+//			Debug.Assert((queryExpressionGroupClause.GroupBy != null));
+//			nodeStack.Push(queryExpressionGroupClause.Projection);
+//			queryExpressionGroupClause.Projection.AcceptVisitor(this, data);
+//			queryExpressionGroupClause.Projection = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(queryExpressionGroupClause.GroupBy);
+//			queryExpressionGroupClause.GroupBy.AcceptVisitor(this, data);
+//			queryExpressionGroupClause.GroupBy = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
+//			Debug.Assert((queryExpressionGroupJoinVBClause != null));
+//			Debug.Assert((queryExpressionGroupJoinVBClause.JoinClause != null));
+//			Debug.Assert((queryExpressionGroupJoinVBClause.IntoVariables != null));
+//			nodeStack.Push(queryExpressionGroupJoinVBClause.JoinClause);
+//			queryExpressionGroupJoinVBClause.JoinClause.AcceptVisitor(this, data);
+//			queryExpressionGroupJoinVBClause.JoinClause = ((QueryExpressionJoinVBClause)(nodeStack.Pop()));
+//			for (int i = 0; i < queryExpressionGroupJoinVBClause.IntoVariables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionGroupJoinVBClause.IntoVariables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionGroupJoinVBClause.IntoVariables.RemoveAt(i--);
+//				else
+//					queryExpressionGroupJoinVBClause.IntoVariables[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
+//			Debug.Assert((queryExpressionGroupVBClause != null));
+//			Debug.Assert((queryExpressionGroupVBClause.GroupVariables != null));
+//			Debug.Assert((queryExpressionGroupVBClause.ByVariables != null));
+//			Debug.Assert((queryExpressionGroupVBClause.IntoVariables != null));
+//			for (int i = 0; i < queryExpressionGroupVBClause.GroupVariables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionGroupVBClause.GroupVariables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionGroupVBClause.GroupVariables.RemoveAt(i--);
+//				else
+//					queryExpressionGroupVBClause.GroupVariables[i] = o;
+//			}
+//			for (int i = 0; i < queryExpressionGroupVBClause.ByVariables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionGroupVBClause.ByVariables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionGroupVBClause.ByVariables.RemoveAt(i--);
+//				else
+//					queryExpressionGroupVBClause.ByVariables[i] = o;
+//			}
+//			for (int i = 0; i < queryExpressionGroupVBClause.IntoVariables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionGroupVBClause.IntoVariables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionGroupVBClause.IntoVariables.RemoveAt(i--);
+//				else
+//					queryExpressionGroupVBClause.IntoVariables[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
+//			Debug.Assert((queryExpressionJoinClause != null));
+//			Debug.Assert((queryExpressionJoinClause.OnExpression != null));
+//			Debug.Assert((queryExpressionJoinClause.EqualsExpression != null));
+//			Debug.Assert((queryExpressionJoinClause.Source != null));
+//			nodeStack.Push(queryExpressionJoinClause.OnExpression);
+//			queryExpressionJoinClause.OnExpression.AcceptVisitor(this, data);
+//			queryExpressionJoinClause.OnExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(queryExpressionJoinClause.EqualsExpression);
+//			queryExpressionJoinClause.EqualsExpression.AcceptVisitor(this, data);
+//			queryExpressionJoinClause.EqualsExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(queryExpressionJoinClause.Source);
+//			queryExpressionJoinClause.Source.AcceptVisitor(this, data);
+//			queryExpressionJoinClause.Source = ((CollectionRangeVariable)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
+//			Debug.Assert((queryExpressionJoinConditionVB != null));
+//			Debug.Assert((queryExpressionJoinConditionVB.LeftSide != null));
+//			Debug.Assert((queryExpressionJoinConditionVB.RightSide != null));
+//			nodeStack.Push(queryExpressionJoinConditionVB.LeftSide);
+//			queryExpressionJoinConditionVB.LeftSide.AcceptVisitor(this, data);
+//			queryExpressionJoinConditionVB.LeftSide = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(queryExpressionJoinConditionVB.RightSide);
+//			queryExpressionJoinConditionVB.RightSide.AcceptVisitor(this, data);
+//			queryExpressionJoinConditionVB.RightSide = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
+//			Debug.Assert((queryExpressionJoinVBClause != null));
+//			Debug.Assert((queryExpressionJoinVBClause.JoinVariable != null));
+//			Debug.Assert((queryExpressionJoinVBClause.SubJoin != null));
+//			Debug.Assert((queryExpressionJoinVBClause.Conditions != null));
+//			nodeStack.Push(queryExpressionJoinVBClause.JoinVariable);
+//			queryExpressionJoinVBClause.JoinVariable.AcceptVisitor(this, data);
+//			queryExpressionJoinVBClause.JoinVariable = ((CollectionRangeVariable)(nodeStack.Pop()));
+//			nodeStack.Push(queryExpressionJoinVBClause.SubJoin);
+//			queryExpressionJoinVBClause.SubJoin.AcceptVisitor(this, data);
+//			queryExpressionJoinVBClause.SubJoin = ((QueryExpressionJoinVBClause)(nodeStack.Pop()));
+//			for (int i = 0; i < queryExpressionJoinVBClause.Conditions.Count; i++) {
+//				QueryExpressionJoinConditionVB o = queryExpressionJoinVBClause.Conditions[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (QueryExpressionJoinConditionVB)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionJoinVBClause.Conditions.RemoveAt(i--);
+//				else
+//					queryExpressionJoinVBClause.Conditions[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetVBClause, object data) {
+//			Debug.Assert((queryExpressionLetVBClause != null));
+//			Debug.Assert((queryExpressionLetVBClause.Variables != null));
+//			for (int i = 0; i < queryExpressionLetVBClause.Variables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionLetVBClause.Variables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionLetVBClause.Variables.RemoveAt(i--);
+//				else
+//					queryExpressionLetVBClause.Variables[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
+//			Debug.Assert((queryExpressionOrderClause != null));
+//			Debug.Assert((queryExpressionOrderClause.Orderings != null));
+//			for (int i = 0; i < queryExpressionOrderClause.Orderings.Count; i++) {
+//				QueryExpressionOrdering o = queryExpressionOrderClause.Orderings[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (QueryExpressionOrdering)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionOrderClause.Orderings.RemoveAt(i--);
+//				else
+//					queryExpressionOrderClause.Orderings[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
+//			Debug.Assert((queryExpressionOrdering != null));
+//			Debug.Assert((queryExpressionOrdering.Criteria != null));
+//			nodeStack.Push(queryExpressionOrdering.Criteria);
+//			queryExpressionOrdering.Criteria.AcceptVisitor(this, data);
+//			queryExpressionOrdering.Criteria = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
+//			Debug.Assert((queryExpressionPartitionVBClause != null));
+//			Debug.Assert((queryExpressionPartitionVBClause.Expression != null));
+//			nodeStack.Push(queryExpressionPartitionVBClause.Expression);
+//			queryExpressionPartitionVBClause.Expression.AcceptVisitor(this, data);
+//			queryExpressionPartitionVBClause.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
+//			Debug.Assert((queryExpressionSelectClause != null));
+//			Debug.Assert((queryExpressionSelectClause.Projection != null));
+//			nodeStack.Push(queryExpressionSelectClause.Projection);
+//			queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
+//			queryExpressionSelectClause.Projection = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
+//			Debug.Assert((queryExpressionSelectVBClause != null));
+//			Debug.Assert((queryExpressionSelectVBClause.Variables != null));
+//			for (int i = 0; i < queryExpressionSelectVBClause.Variables.Count; i++) {
+//				ExpressionRangeVariable o = queryExpressionSelectVBClause.Variables[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ExpressionRangeVariable)nodeStack.Pop();
+//				if (o == null)
+//					queryExpressionSelectVBClause.Variables.RemoveAt(i--);
+//				else
+//					queryExpressionSelectVBClause.Variables[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
+//			Debug.Assert((queryExpressionWhereClause != null));
+//			Debug.Assert((queryExpressionWhereClause.Condition != null));
+//			nodeStack.Push(queryExpressionWhereClause.Condition);
+//			queryExpressionWhereClause.Condition.AcceptVisitor(this, data);
+//			queryExpressionWhereClause.Condition = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
+//			Debug.Assert((raiseEventStatement != null));
+//			Debug.Assert((raiseEventStatement.Arguments != null));
+//			for (int i = 0; i < raiseEventStatement.Arguments.Count; i++) {
+//				Expression o = raiseEventStatement.Arguments[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (Expression)nodeStack.Pop();
+//				if (o == null)
+//					raiseEventStatement.Arguments.RemoveAt(i--);
+//				else
+//					raiseEventStatement.Arguments[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
+//			Debug.Assert((reDimStatement != null));
+//			Debug.Assert((reDimStatement.ReDimClauses != null));
+//			for (int i = 0; i < reDimStatement.ReDimClauses.Count; i++) {
+//				InvocationExpression o = reDimStatement.ReDimClauses[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (InvocationExpression)nodeStack.Pop();
+//				if (o == null)
+//					reDimStatement.ReDimClauses.RemoveAt(i--);
+//				else
+//					reDimStatement.ReDimClauses[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
+//			Debug.Assert((removeHandlerStatement != null));
+//			Debug.Assert((removeHandlerStatement.EventExpression != null));
+//			Debug.Assert((removeHandlerStatement.HandlerExpression != null));
+//			nodeStack.Push(removeHandlerStatement.EventExpression);
+//			removeHandlerStatement.EventExpression.AcceptVisitor(this, data);
+//			removeHandlerStatement.EventExpression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(removeHandlerStatement.HandlerExpression);
+//			removeHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
+//			removeHandlerStatement.HandlerExpression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
+//			Debug.Assert((resumeStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitReturnStatement(ReturnStatement returnStatement, object data) {
+//			Debug.Assert((returnStatement != null));
+//			Debug.Assert((returnStatement.Expression != null));
+//			nodeStack.Push(returnStatement.Expression);
+//			returnStatement.Expression.AcceptVisitor(this, data);
+//			returnStatement.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitStopStatement(StopStatement stopStatement, object data) {
+//			Debug.Assert((stopStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitSwitchSection(SwitchSection switchSection, object data) {
+//			Debug.Assert((switchSection != null));
+//			Debug.Assert((switchSection.SwitchLabels != null));
+//			for (int i = 0; i < switchSection.SwitchLabels.Count; i++) {
+//				CaseLabel o = switchSection.SwitchLabels[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (CaseLabel)nodeStack.Pop();
+//				if (o == null)
+//					switchSection.SwitchLabels.RemoveAt(i--);
+//				else
+//					switchSection.SwitchLabels[i] = o;
+//			}
+//			for (int i = 0; i < switchSection.Children.Count; i++) {
+//				INode o = switchSection.Children[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = nodeStack.Pop();
+//				if (o == null)
+//					switchSection.Children.RemoveAt(i--);
+//				else
+//					switchSection.Children[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
+//			Debug.Assert((switchStatement != null));
+//			Debug.Assert((switchStatement.SwitchExpression != null));
+//			Debug.Assert((switchStatement.SwitchSections != null));
+//			nodeStack.Push(switchStatement.SwitchExpression);
+//			switchStatement.SwitchExpression.AcceptVisitor(this, data);
+//			switchStatement.SwitchExpression = ((Expression)(nodeStack.Pop()));
+//			for (int i = 0; i < switchStatement.SwitchSections.Count; i++) {
+//				SwitchSection o = switchStatement.SwitchSections[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (SwitchSection)nodeStack.Pop();
+//				if (o == null)
+//					switchStatement.SwitchSections.RemoveAt(i--);
+//				else
+//					switchStatement.SwitchSections[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
+//			Debug.Assert((templateDefinition != null));
+//			Debug.Assert((templateDefinition.Attributes != null));
+//			Debug.Assert((templateDefinition.Bases != null));
+//			for (int i = 0; i < templateDefinition.Attributes.Count; i++) {
+//				AttributeSection o = templateDefinition.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					templateDefinition.Attributes.RemoveAt(i--);
+//				else
+//					templateDefinition.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < templateDefinition.Bases.Count; i++) {
+//				TypeReference o = templateDefinition.Bases[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TypeReference)nodeStack.Pop();
+//				if (o == null)
+//					templateDefinition.Bases.RemoveAt(i--);
+//				else
+//					templateDefinition.Bases[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
+//			Debug.Assert((thisReferenceExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitThrowStatement(ThrowStatement throwStatement, object data) {
+//			Debug.Assert((throwStatement != null));
+//			Debug.Assert((throwStatement.Expression != null));
+//			nodeStack.Push(throwStatement.Expression);
+//			throwStatement.Expression.AcceptVisitor(this, data);
+//			throwStatement.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
+//			Debug.Assert((tryCatchStatement != null));
+//			Debug.Assert((tryCatchStatement.StatementBlock != null));
+//			Debug.Assert((tryCatchStatement.CatchClauses != null));
+//			Debug.Assert((tryCatchStatement.FinallyBlock != null));
+//			nodeStack.Push(tryCatchStatement.StatementBlock);
+//			tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
+//			tryCatchStatement.StatementBlock = ((Statement)(nodeStack.Pop()));
+//			for (int i = 0; i < tryCatchStatement.CatchClauses.Count; i++) {
+//				CatchClause o = tryCatchStatement.CatchClauses[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (CatchClause)nodeStack.Pop();
+//				if (o == null)
+//					tryCatchStatement.CatchClauses.RemoveAt(i--);
+//				else
+//					tryCatchStatement.CatchClauses[i] = o;
+//			}
+//			nodeStack.Push(tryCatchStatement.FinallyBlock);
+//			tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
+//			tryCatchStatement.FinallyBlock = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
+//			Debug.Assert((typeDeclaration != null));
+//			Debug.Assert((typeDeclaration.Attributes != null));
+//			Debug.Assert((typeDeclaration.BaseTypes != null));
+//			Debug.Assert((typeDeclaration.Templates != null));
+//			for (int i = 0; i < typeDeclaration.Attributes.Count; i++) {
+//				AttributeSection o = typeDeclaration.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (AttributeSection)nodeStack.Pop();
+//				if (o == null)
+//					typeDeclaration.Attributes.RemoveAt(i--);
+//				else
+//					typeDeclaration.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < typeDeclaration.BaseTypes.Count; i++) {
+//				TypeReference o = typeDeclaration.BaseTypes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TypeReference)nodeStack.Pop();
+//				if (o == null)
+//					typeDeclaration.BaseTypes.RemoveAt(i--);
+//				else
+//					typeDeclaration.BaseTypes[i] = o;
+//			}
+//			for (int i = 0; i < typeDeclaration.Templates.Count; i++) {
+//				TemplateDefinition o = typeDeclaration.Templates[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TemplateDefinition)nodeStack.Pop();
+//				if (o == null)
+//					typeDeclaration.Templates.RemoveAt(i--);
+//				else
+//					typeDeclaration.Templates[i] = o;
+//			}
+//			for (int i = 0; i < typeDeclaration.Children.Count; i++) {
+//				INode o = typeDeclaration.Children[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = nodeStack.Pop();
+//				if (o == null)
+//					typeDeclaration.Children.RemoveAt(i--);
+//				else
+//					typeDeclaration.Children[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
+//			Debug.Assert((typeOfExpression != null));
+//			Debug.Assert((typeOfExpression.TypeReference != null));
+//			nodeStack.Push(typeOfExpression.TypeReference);
+//			typeOfExpression.TypeReference.AcceptVisitor(this, data);
+//			typeOfExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
+//			Debug.Assert((typeOfIsExpression != null));
+//			Debug.Assert((typeOfIsExpression.Expression != null));
+//			Debug.Assert((typeOfIsExpression.TypeReference != null));
+//			nodeStack.Push(typeOfIsExpression.Expression);
+//			typeOfIsExpression.Expression.AcceptVisitor(this, data);
+//			typeOfIsExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(typeOfIsExpression.TypeReference);
+//			typeOfIsExpression.TypeReference.AcceptVisitor(this, data);
+//			typeOfIsExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitTypeReference(TypeReference typeReference, object data) {
+//			Debug.Assert((typeReference != null));
+//			Debug.Assert((typeReference.GenericTypes != null));
+//			for (int i = 0; i < typeReference.GenericTypes.Count; i++) {
+//				TypeReference o = typeReference.GenericTypes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (TypeReference)nodeStack.Pop();
+//				if (o == null)
+//					typeReference.GenericTypes.RemoveAt(i--);
+//				else
+//					typeReference.GenericTypes[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
+//			Debug.Assert((typeReferenceExpression != null));
+//			Debug.Assert((typeReferenceExpression.TypeReference != null));
+//			nodeStack.Push(typeReferenceExpression.TypeReference);
+//			typeReferenceExpression.TypeReference.AcceptVisitor(this, data);
+//			typeReferenceExpression.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
+//			Debug.Assert((unaryOperatorExpression != null));
+//			Debug.Assert((unaryOperatorExpression.Expression != null));
+//			nodeStack.Push(unaryOperatorExpression.Expression);
+//			unaryOperatorExpression.Expression.AcceptVisitor(this, data);
+//			unaryOperatorExpression.Expression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitUsing(ImportsClause @using, object data) {
+//			Debug.Assert((@using != null));
+//			Debug.Assert((@using.Alias != null));
+//			nodeStack.Push(@using.Alias);
+//			@using.Alias.AcceptVisitor(this, data);
+//			@using.Alias = ((TypeReference)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitUsingDeclaration(ImportsStatement usingDeclaration, object data) {
+//			Debug.Assert((usingDeclaration != null));
+//			Debug.Assert((usingDeclaration.ImportsClauses != null));
+//			for (int i = 0; i < usingDeclaration.ImportsClauses.Count; i++) {
+//				ImportsClause o = usingDeclaration.ImportsClauses[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (ImportsClause)nodeStack.Pop();
+//				if (o == null)
+//					usingDeclaration.ImportsClauses.RemoveAt(i--);
+//				else
+//					usingDeclaration.ImportsClauses[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitUsingStatement(UsingStatement usingStatement, object data) {
+//			Debug.Assert((usingStatement != null));
+//			Debug.Assert((usingStatement.ResourceAcquisition != null));
+//			Debug.Assert((usingStatement.EmbeddedStatement != null));
+//			nodeStack.Push(usingStatement.ResourceAcquisition);
+//			usingStatement.ResourceAcquisition.AcceptVisitor(this, data);
+//			usingStatement.ResourceAcquisition = ((Statement)(nodeStack.Pop()));
+//			nodeStack.Push(usingStatement.EmbeddedStatement);
+//			usingStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//			usingStatement.EmbeddedStatement = ((Statement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
+//			Debug.Assert((variableDeclaration != null));
+//			Debug.Assert((variableDeclaration.Initializer != null));
+//			Debug.Assert((variableDeclaration.TypeReference != null));
+//			Debug.Assert((variableDeclaration.FixedArrayInitialization != null));
+//			nodeStack.Push(variableDeclaration.Initializer);
+//			variableDeclaration.Initializer.AcceptVisitor(this, data);
+//			variableDeclaration.Initializer = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(variableDeclaration.TypeReference);
+//			variableDeclaration.TypeReference.AcceptVisitor(this, data);
+//			variableDeclaration.TypeReference = ((TypeReference)(nodeStack.Pop()));
+//			nodeStack.Push(variableDeclaration.FixedArrayInitialization);
+//			variableDeclaration.FixedArrayInitialization.AcceptVisitor(this, data);
+//			variableDeclaration.FixedArrayInitialization = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitWithStatement(WithStatement withStatement, object data) {
+//			Debug.Assert((withStatement != null));
+//			Debug.Assert((withStatement.Expression != null));
+//			Debug.Assert((withStatement.Body != null));
+//			nodeStack.Push(withStatement.Expression);
+//			withStatement.Expression.AcceptVisitor(this, data);
+//			withStatement.Expression = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(withStatement.Body);
+//			withStatement.Body.AcceptVisitor(this, data);
+//			withStatement.Body = ((BlockStatement)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
+//			Debug.Assert((xmlAttributeExpression != null));
+//			Debug.Assert((xmlAttributeExpression.ExpressionValue != null));
+//			nodeStack.Push(xmlAttributeExpression.ExpressionValue);
+//			xmlAttributeExpression.ExpressionValue.AcceptVisitor(this, data);
+//			xmlAttributeExpression.ExpressionValue = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+//			Debug.Assert((xmlContentExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+//			Debug.Assert((xmlDocumentExpression != null));
+//			Debug.Assert((xmlDocumentExpression.Expressions != null));
+//			for (int i = 0; i < xmlDocumentExpression.Expressions.Count; i++) {
+//				XmlExpression o = xmlDocumentExpression.Expressions[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (XmlExpression)nodeStack.Pop();
+//				if (o == null)
+//					xmlDocumentExpression.Expressions.RemoveAt(i--);
+//				else
+//					xmlDocumentExpression.Expressions[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+//			Debug.Assert((xmlElementExpression != null));
+//			Debug.Assert((xmlElementExpression.Content != null));
+//			Debug.Assert((xmlElementExpression.NameExpression != null));
+//			Debug.Assert((xmlElementExpression.Attributes != null));
+//			nodeStack.Push(xmlElementExpression.Content);
+//			xmlElementExpression.Content.AcceptVisitor(this, data);
+//			xmlElementExpression.Content = ((Expression)(nodeStack.Pop()));
+//			nodeStack.Push(xmlElementExpression.NameExpression);
+//			xmlElementExpression.NameExpression.AcceptVisitor(this, data);
+//			xmlElementExpression.NameExpression = ((Expression)(nodeStack.Pop()));
+//			for (int i = 0; i < xmlElementExpression.Attributes.Count; i++) {
+//				XmlExpression o = xmlElementExpression.Attributes[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = (XmlExpression)nodeStack.Pop();
+//				if (o == null)
+//					xmlElementExpression.Attributes.RemoveAt(i--);
+//				else
+//					xmlElementExpression.Attributes[i] = o;
+//			}
+//			for (int i = 0; i < xmlElementExpression.Children.Count; i++) {
+//				INode o = xmlElementExpression.Children[i];
+//				Debug.Assert(o != null);
+//				nodeStack.Push(o);
+//				o.AcceptVisitor(this, data);
+//				o = nodeStack.Pop();
+//				if (o == null)
+//					xmlElementExpression.Children.RemoveAt(i--);
+//				else
+//					xmlElementExpression.Children[i] = o;
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+//			Debug.Assert((xmlEmbeddedExpression != null));
+//			Debug.Assert((xmlEmbeddedExpression.InlineVBExpression != null));
+//			nodeStack.Push(xmlEmbeddedExpression.InlineVBExpression);
+//			xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
+//			xmlEmbeddedExpression.InlineVBExpression = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
+//			Debug.Assert((xmlMemberAccessExpression != null));
+//			Debug.Assert((xmlMemberAccessExpression.TargetObject != null));
+//			nodeStack.Push(xmlMemberAccessExpression.TargetObject);
+//			xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
+//			xmlMemberAccessExpression.TargetObject = ((Expression)(nodeStack.Pop()));
+//			return null;
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstVisitor.cs
index 40673247f..6f4497441 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/AbstractAstVisitor.cs
@@ -15,1142 +15,1142 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	using ICSharpCode.NRefactory.VB.Ast;
 	
 	
-	public abstract class AbstractAstVisitor : IAstVisitor {
-		
-		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
-			Debug.Assert((addHandlerStatement != null));
-			Debug.Assert((addHandlerStatement.EventExpression != null));
-			Debug.Assert((addHandlerStatement.HandlerExpression != null));
-			addHandlerStatement.EventExpression.AcceptVisitor(this, data);
-			return addHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
-			Debug.Assert((addressOfExpression != null));
-			Debug.Assert((addressOfExpression.Expression != null));
-			return addressOfExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
-			Debug.Assert((arrayCreateExpression != null));
-			Debug.Assert((arrayCreateExpression.CreateType != null));
-			Debug.Assert((arrayCreateExpression.Arguments != null));
-			Debug.Assert((arrayCreateExpression.ArrayInitializer != null));
-			arrayCreateExpression.CreateType.AcceptVisitor(this, data);
-			foreach (Expression o in arrayCreateExpression.Arguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
-			Debug.Assert((assignmentExpression != null));
-			Debug.Assert((assignmentExpression.Left != null));
-			Debug.Assert((assignmentExpression.Right != null));
-			assignmentExpression.Left.AcceptVisitor(this, data);
-			return assignmentExpression.Right.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
-			Debug.Assert((attribute != null));
-			Debug.Assert((attribute.PositionalArguments != null));
-			Debug.Assert((attribute.NamedArguments != null));
-			foreach (Expression o in attribute.PositionalArguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (NamedArgumentExpression o in attribute.NamedArguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitAttributeSection(AttributeSection attributeSection, object data) {
-			Debug.Assert((attributeSection != null));
-			Debug.Assert((attributeSection.Attributes != null));
-			foreach (ICSharpCode.NRefactory.VB.Ast.Attribute o in attributeSection.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
-			Debug.Assert((baseReferenceExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
-			Debug.Assert((binaryOperatorExpression != null));
-			Debug.Assert((binaryOperatorExpression.Left != null));
-			Debug.Assert((binaryOperatorExpression.Right != null));
-			binaryOperatorExpression.Left.AcceptVisitor(this, data);
-			return binaryOperatorExpression.Right.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitBlockStatement(BlockStatement blockStatement, object data) {
-			Debug.Assert((blockStatement != null));
-			return blockStatement.AcceptChildren(this, data);
-		}
-		
-		public virtual object VisitCaseLabel(CaseLabel caseLabel, object data) {
-			Debug.Assert((caseLabel != null));
-			Debug.Assert((caseLabel.Label != null));
-			Debug.Assert((caseLabel.ToExpression != null));
-			caseLabel.Label.AcceptVisitor(this, data);
-			return caseLabel.ToExpression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitCastExpression(CastExpression castExpression, object data) {
-			Debug.Assert((castExpression != null));
-			Debug.Assert((castExpression.CastTo != null));
-			Debug.Assert((castExpression.Expression != null));
-			castExpression.CastTo.AcceptVisitor(this, data);
-			return castExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitCatchClause(CatchClause catchClause, object data) {
-			Debug.Assert((catchClause != null));
-			Debug.Assert((catchClause.TypeReference != null));
-			Debug.Assert((catchClause.StatementBlock != null));
-			Debug.Assert((catchClause.Condition != null));
-			catchClause.TypeReference.AcceptVisitor(this, data);
-			catchClause.StatementBlock.AcceptVisitor(this, data);
-			return catchClause.Condition.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
-			Debug.Assert((classReferenceExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
-			Debug.Assert((collectionInitializerExpression != null));
-			Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
-			foreach (Expression o in collectionInitializerExpression.CreateExpressions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
-			Debug.Assert((collectionRangeVariable != null));
-			Debug.Assert((collectionRangeVariable.Expression != null));
-			Debug.Assert((collectionRangeVariable.Type != null));
-			collectionRangeVariable.Expression.AcceptVisitor(this, data);
-			return collectionRangeVariable.Type.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
-			Debug.Assert((compilationUnit != null));
-			return compilationUnit.AcceptChildren(this, data);
-		}
-		
-		public virtual object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
-			Debug.Assert((conditionalExpression != null));
-			Debug.Assert((conditionalExpression.Condition != null));
-			Debug.Assert((conditionalExpression.TrueExpression != null));
-			Debug.Assert((conditionalExpression.FalseExpression != null));
-			conditionalExpression.Condition.AcceptVisitor(this, data);
-			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
-			return conditionalExpression.FalseExpression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
-			Debug.Assert((constructorDeclaration != null));
-			Debug.Assert((constructorDeclaration.Attributes != null));
-			Debug.Assert((constructorDeclaration.Parameters != null));
-			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
-			Debug.Assert((constructorDeclaration.Body != null));
-			foreach (AttributeSection o in constructorDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ParameterDeclarationExpression o in constructorDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
-			return constructorDeclaration.Body.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
-			Debug.Assert((constructorInitializer != null));
-			Debug.Assert((constructorInitializer.Arguments != null));
-			foreach (Expression o in constructorInitializer.Arguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitContinueStatement(ContinueStatement continueStatement, object data) {
-			Debug.Assert((continueStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
-			Debug.Assert((declareDeclaration != null));
-			Debug.Assert((declareDeclaration.Attributes != null));
-			Debug.Assert((declareDeclaration.Parameters != null));
-			Debug.Assert((declareDeclaration.TypeReference != null));
-			foreach (AttributeSection o in declareDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ParameterDeclarationExpression o in declareDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return declareDeclaration.TypeReference.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
-			Debug.Assert((defaultValueExpression != null));
-			Debug.Assert((defaultValueExpression.TypeReference != null));
-			return defaultValueExpression.TypeReference.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
-			Debug.Assert((delegateDeclaration != null));
-			Debug.Assert((delegateDeclaration.Attributes != null));
-			Debug.Assert((delegateDeclaration.ReturnType != null));
-			Debug.Assert((delegateDeclaration.Parameters != null));
-			Debug.Assert((delegateDeclaration.Templates != null));
-			foreach (AttributeSection o in delegateDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			delegateDeclaration.ReturnType.AcceptVisitor(this, data);
-			foreach (ParameterDeclarationExpression o in delegateDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (TemplateDefinition o in delegateDeclaration.Templates) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
-			Debug.Assert((directionExpression != null));
-			Debug.Assert((directionExpression.Expression != null));
-			return directionExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
-			Debug.Assert((doLoopStatement != null));
-			Debug.Assert((doLoopStatement.Condition != null));
-			Debug.Assert((doLoopStatement.EmbeddedStatement != null));
-			doLoopStatement.Condition.AcceptVisitor(this, data);
-			return doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
-			Debug.Assert((elseIfSection != null));
-			Debug.Assert((elseIfSection.Condition != null));
-			Debug.Assert((elseIfSection.EmbeddedStatement != null));
-			elseIfSection.Condition.AcceptVisitor(this, data);
-			return elseIfSection.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitEndStatement(EndStatement endStatement, object data) {
-			Debug.Assert((endStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitEraseStatement(EraseStatement eraseStatement, object data) {
-			Debug.Assert((eraseStatement != null));
-			Debug.Assert((eraseStatement.Expressions != null));
-			foreach (Expression o in eraseStatement.Expressions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitErrorStatement(ErrorStatement errorStatement, object data) {
-			Debug.Assert((errorStatement != null));
-			Debug.Assert((errorStatement.Expression != null));
-			return errorStatement.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
-			Debug.Assert((eventAddRegion != null));
-			Debug.Assert((eventAddRegion.Attributes != null));
-			Debug.Assert((eventAddRegion.Block != null));
-			Debug.Assert((eventAddRegion.Parameters != null));
-			foreach (AttributeSection o in eventAddRegion.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			eventAddRegion.Block.AcceptVisitor(this, data);
-			foreach (ParameterDeclarationExpression o in eventAddRegion.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
-			Debug.Assert((eventDeclaration != null));
-			Debug.Assert((eventDeclaration.Attributes != null));
-			Debug.Assert((eventDeclaration.Parameters != null));
-			Debug.Assert((eventDeclaration.InterfaceImplementations != null));
-			Debug.Assert((eventDeclaration.TypeReference != null));
-			Debug.Assert((eventDeclaration.AddRegion != null));
-			Debug.Assert((eventDeclaration.RemoveRegion != null));
-			Debug.Assert((eventDeclaration.RaiseRegion != null));
-			Debug.Assert((eventDeclaration.Initializer != null));
-			foreach (AttributeSection o in eventDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ParameterDeclarationExpression o in eventDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (InterfaceImplementation o in eventDeclaration.InterfaceImplementations) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			eventDeclaration.TypeReference.AcceptVisitor(this, data);
-			eventDeclaration.AddRegion.AcceptVisitor(this, data);
-			eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
-			eventDeclaration.RaiseRegion.AcceptVisitor(this, data);
-			return eventDeclaration.Initializer.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
-			Debug.Assert((eventRaiseRegion != null));
-			Debug.Assert((eventRaiseRegion.Attributes != null));
-			Debug.Assert((eventRaiseRegion.Block != null));
-			Debug.Assert((eventRaiseRegion.Parameters != null));
-			foreach (AttributeSection o in eventRaiseRegion.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			eventRaiseRegion.Block.AcceptVisitor(this, data);
-			foreach (ParameterDeclarationExpression o in eventRaiseRegion.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
-			Debug.Assert((eventRemoveRegion != null));
-			Debug.Assert((eventRemoveRegion.Attributes != null));
-			Debug.Assert((eventRemoveRegion.Block != null));
-			Debug.Assert((eventRemoveRegion.Parameters != null));
-			foreach (AttributeSection o in eventRemoveRegion.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			eventRemoveRegion.Block.AcceptVisitor(this, data);
-			foreach (ParameterDeclarationExpression o in eventRemoveRegion.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitExitStatement(ExitStatement exitStatement, object data) {
-			Debug.Assert((exitStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
-			Debug.Assert((expressionRangeVariable != null));
-			Debug.Assert((expressionRangeVariable.Expression != null));
-			Debug.Assert((expressionRangeVariable.Type != null));
-			expressionRangeVariable.Expression.AcceptVisitor(this, data);
-			return expressionRangeVariable.Type.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
-			Debug.Assert((expressionStatement != null));
-			Debug.Assert((expressionStatement.Expression != null));
-			return expressionStatement.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
-			Debug.Assert((externAliasDirective != null));
-			return null;
-		}
-		
-		public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
-			Debug.Assert((fieldDeclaration != null));
-			Debug.Assert((fieldDeclaration.Attributes != null));
-			Debug.Assert((fieldDeclaration.TypeReference != null));
-			Debug.Assert((fieldDeclaration.Fields != null));
-			foreach (AttributeSection o in fieldDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			fieldDeclaration.TypeReference.AcceptVisitor(this, data);
-			foreach (VariableDeclaration o in fieldDeclaration.Fields) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
-			Debug.Assert((foreachStatement != null));
-			Debug.Assert((foreachStatement.TypeReference != null));
-			Debug.Assert((foreachStatement.Expression != null));
-			Debug.Assert((foreachStatement.NextExpression != null));
-			Debug.Assert((foreachStatement.EmbeddedStatement != null));
-			foreachStatement.TypeReference.AcceptVisitor(this, data);
-			foreachStatement.Expression.AcceptVisitor(this, data);
-			foreachStatement.NextExpression.AcceptVisitor(this, data);
-			return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
-			Debug.Assert((forNextStatement != null));
-			Debug.Assert((forNextStatement.Start != null));
-			Debug.Assert((forNextStatement.End != null));
-			Debug.Assert((forNextStatement.Step != null));
-			Debug.Assert((forNextStatement.NextExpressions != null));
-			Debug.Assert((forNextStatement.TypeReference != null));
-			Debug.Assert((forNextStatement.LoopVariableExpression != null));
-			Debug.Assert((forNextStatement.EmbeddedStatement != null));
-			forNextStatement.Start.AcceptVisitor(this, data);
-			forNextStatement.End.AcceptVisitor(this, data);
-			forNextStatement.Step.AcceptVisitor(this, data);
-			foreach (Expression o in forNextStatement.NextExpressions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			forNextStatement.TypeReference.AcceptVisitor(this, data);
-			forNextStatement.LoopVariableExpression.AcceptVisitor(this, data);
-			return forNextStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitGotoStatement(GotoStatement gotoStatement, object data) {
-			Debug.Assert((gotoStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
-			Debug.Assert((identifierExpression != null));
-			Debug.Assert((identifierExpression.TypeArguments != null));
-			foreach (TypeReference o in identifierExpression.TypeArguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
-			Debug.Assert((ifElseStatement != null));
-			Debug.Assert((ifElseStatement.Condition != null));
-			Debug.Assert((ifElseStatement.TrueStatement != null));
-			Debug.Assert((ifElseStatement.FalseStatement != null));
-			Debug.Assert((ifElseStatement.ElseIfSections != null));
-			ifElseStatement.Condition.AcceptVisitor(this, data);
-			foreach (Statement o in ifElseStatement.TrueStatement) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (Statement o in ifElseStatement.FalseStatement) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ElseIfSection o in ifElseStatement.ElseIfSections) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
-			Debug.Assert((innerClassTypeReference != null));
-			Debug.Assert((innerClassTypeReference.GenericTypes != null));
-			Debug.Assert((innerClassTypeReference.BaseType != null));
-			foreach (TypeReference o in innerClassTypeReference.GenericTypes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return innerClassTypeReference.BaseType.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
-			Debug.Assert((interfaceImplementation != null));
-			Debug.Assert((interfaceImplementation.InterfaceType != null));
-			return interfaceImplementation.InterfaceType.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
-			Debug.Assert((invocationExpression != null));
-			Debug.Assert((invocationExpression.TargetObject != null));
-			Debug.Assert((invocationExpression.Arguments != null));
-			invocationExpression.TargetObject.AcceptVisitor(this, data);
-			foreach (Expression o in invocationExpression.Arguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitLabelStatement(LabelStatement labelStatement, object data) {
-			Debug.Assert((labelStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
-			Debug.Assert((lambdaExpression != null));
-			Debug.Assert((lambdaExpression.Parameters != null));
-			Debug.Assert((lambdaExpression.StatementBody != null));
-			Debug.Assert((lambdaExpression.ExpressionBody != null));
-			Debug.Assert((lambdaExpression.ReturnType != null));
-			foreach (ParameterDeclarationExpression o in lambdaExpression.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			lambdaExpression.StatementBody.AcceptVisitor(this, data);
-			lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
-			return lambdaExpression.ReturnType.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
-			Debug.Assert((localVariableDeclaration != null));
-			Debug.Assert((localVariableDeclaration.TypeReference != null));
-			Debug.Assert((localVariableDeclaration.Variables != null));
-			localVariableDeclaration.TypeReference.AcceptVisitor(this, data);
-			foreach (VariableDeclaration o in localVariableDeclaration.Variables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitLockStatement(LockStatement lockStatement, object data) {
-			Debug.Assert((lockStatement != null));
-			Debug.Assert((lockStatement.LockExpression != null));
-			Debug.Assert((lockStatement.EmbeddedStatement != null));
-			lockStatement.LockExpression.AcceptVisitor(this, data);
-			return lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
-			Debug.Assert((memberInitializerExpression != null));
-			Debug.Assert((memberInitializerExpression.Expression != null));
-			return memberInitializerExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
-			Debug.Assert((memberReferenceExpression != null));
-			Debug.Assert((memberReferenceExpression.TargetObject != null));
-			Debug.Assert((memberReferenceExpression.TypeArguments != null));
-			memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
-			foreach (TypeReference o in memberReferenceExpression.TypeArguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
-			Debug.Assert((methodDeclaration != null));
-			Debug.Assert((methodDeclaration.Attributes != null));
-			Debug.Assert((methodDeclaration.Parameters != null));
-			Debug.Assert((methodDeclaration.InterfaceImplementations != null));
-			Debug.Assert((methodDeclaration.TypeReference != null));
-			Debug.Assert((methodDeclaration.Body != null));
-			Debug.Assert((methodDeclaration.Templates != null));
-			foreach (AttributeSection o in methodDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ParameterDeclarationExpression o in methodDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (InterfaceImplementation o in methodDeclaration.InterfaceImplementations) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			methodDeclaration.TypeReference.AcceptVisitor(this, data);
-			methodDeclaration.Body.AcceptVisitor(this, data);
-			foreach (TemplateDefinition o in methodDeclaration.Templates) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
-			Debug.Assert((namedArgumentExpression != null));
-			Debug.Assert((namedArgumentExpression.Expression != null));
-			return namedArgumentExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
-			Debug.Assert((namespaceDeclaration != null));
-			return namespaceDeclaration.AcceptChildren(this, data);
-		}
-		
-		public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
-			Debug.Assert((objectCreateExpression != null));
-			Debug.Assert((objectCreateExpression.CreateType != null));
-			Debug.Assert((objectCreateExpression.Parameters != null));
-			Debug.Assert((objectCreateExpression.ObjectInitializer != null));
-			objectCreateExpression.CreateType.AcceptVisitor(this, data);
-			foreach (Expression o in objectCreateExpression.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
-			Debug.Assert((onErrorStatement != null));
-			Debug.Assert((onErrorStatement.EmbeddedStatement != null));
-			return onErrorStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
-			Debug.Assert((operatorDeclaration != null));
-			Debug.Assert((operatorDeclaration.Attributes != null));
-			Debug.Assert((operatorDeclaration.Parameters != null));
-			Debug.Assert((operatorDeclaration.InterfaceImplementations != null));
-			Debug.Assert((operatorDeclaration.TypeReference != null));
-			Debug.Assert((operatorDeclaration.Body != null));
-			Debug.Assert((operatorDeclaration.Templates != null));
-			foreach (AttributeSection o in operatorDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ParameterDeclarationExpression o in operatorDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (InterfaceImplementation o in operatorDeclaration.InterfaceImplementations) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			operatorDeclaration.TypeReference.AcceptVisitor(this, data);
-			operatorDeclaration.Body.AcceptVisitor(this, data);
-			foreach (TemplateDefinition o in operatorDeclaration.Templates) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
-			Debug.Assert((optionDeclaration != null));
-			return null;
-		}
-		
-		public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
-			Debug.Assert((parameterDeclarationExpression != null));
-			Debug.Assert((parameterDeclarationExpression.Attributes != null));
-			Debug.Assert((parameterDeclarationExpression.TypeReference != null));
-			Debug.Assert((parameterDeclarationExpression.DefaultValue != null));
-			foreach (AttributeSection o in parameterDeclarationExpression.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data);
-			return parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
-			Debug.Assert((parenthesizedExpression != null));
-			Debug.Assert((parenthesizedExpression.Expression != null));
-			return parenthesizedExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
-			Debug.Assert((primitiveExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
-			Debug.Assert((propertyDeclaration != null));
-			Debug.Assert((propertyDeclaration.Attributes != null));
-			Debug.Assert((propertyDeclaration.Parameters != null));
-			Debug.Assert((propertyDeclaration.InterfaceImplementations != null));
-			Debug.Assert((propertyDeclaration.TypeReference != null));
-			Debug.Assert((propertyDeclaration.GetRegion != null));
-			Debug.Assert((propertyDeclaration.SetRegion != null));
-			Debug.Assert((propertyDeclaration.Initializer != null));
-			foreach (AttributeSection o in propertyDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ParameterDeclarationExpression o in propertyDeclaration.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (InterfaceImplementation o in propertyDeclaration.InterfaceImplementations) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			propertyDeclaration.TypeReference.AcceptVisitor(this, data);
-			propertyDeclaration.GetRegion.AcceptVisitor(this, data);
-			propertyDeclaration.SetRegion.AcceptVisitor(this, data);
-			return propertyDeclaration.Initializer.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
-			Debug.Assert((propertyGetRegion != null));
-			Debug.Assert((propertyGetRegion.Attributes != null));
-			Debug.Assert((propertyGetRegion.Block != null));
-			foreach (AttributeSection o in propertyGetRegion.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return propertyGetRegion.Block.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
-			Debug.Assert((propertySetRegion != null));
-			Debug.Assert((propertySetRegion.Attributes != null));
-			Debug.Assert((propertySetRegion.Block != null));
-			Debug.Assert((propertySetRegion.Parameters != null));
-			foreach (AttributeSection o in propertySetRegion.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			propertySetRegion.Block.AcceptVisitor(this, data);
-			foreach (ParameterDeclarationExpression o in propertySetRegion.Parameters) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
-			Debug.Assert((queryExpression != null));
-			Debug.Assert((queryExpression.Clauses != null));
-			foreach (QueryExpressionClause o in queryExpression.Clauses) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
-			Debug.Assert((queryExpressionAggregateClause != null));
-			Debug.Assert((queryExpressionAggregateClause.Source != null));
-			Debug.Assert((queryExpressionAggregateClause.MiddleClauses != null));
-			Debug.Assert((queryExpressionAggregateClause.IntoVariables != null));
-			queryExpressionAggregateClause.Source.AcceptVisitor(this, data);
-			foreach (QueryExpressionClause o in queryExpressionAggregateClause.MiddleClauses) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ExpressionRangeVariable o in queryExpressionAggregateClause.IntoVariables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
-			Debug.Assert((queryExpressionDistinctClause != null));
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
-			Debug.Assert((queryExpressionFromClause != null));
-			Debug.Assert((queryExpressionFromClause.Sources != null));
-			foreach (CollectionRangeVariable o in queryExpressionFromClause.Sources) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
-			Debug.Assert((queryExpressionGroupClause != null));
-			Debug.Assert((queryExpressionGroupClause.Projection != null));
-			Debug.Assert((queryExpressionGroupClause.GroupBy != null));
-			queryExpressionGroupClause.Projection.AcceptVisitor(this, data);
-			return queryExpressionGroupClause.GroupBy.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
-			Debug.Assert((queryExpressionGroupJoinVBClause != null));
-			Debug.Assert((queryExpressionGroupJoinVBClause.JoinClause != null));
-			Debug.Assert((queryExpressionGroupJoinVBClause.IntoVariables != null));
-			queryExpressionGroupJoinVBClause.JoinClause.AcceptVisitor(this, data);
-			foreach (ExpressionRangeVariable o in queryExpressionGroupJoinVBClause.IntoVariables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
-			Debug.Assert((queryExpressionGroupVBClause != null));
-			Debug.Assert((queryExpressionGroupVBClause.GroupVariables != null));
-			Debug.Assert((queryExpressionGroupVBClause.ByVariables != null));
-			Debug.Assert((queryExpressionGroupVBClause.IntoVariables != null));
-			foreach (ExpressionRangeVariable o in queryExpressionGroupVBClause.GroupVariables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ExpressionRangeVariable o in queryExpressionGroupVBClause.ByVariables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (ExpressionRangeVariable o in queryExpressionGroupVBClause.IntoVariables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
-			Debug.Assert((queryExpressionJoinClause != null));
-			Debug.Assert((queryExpressionJoinClause.OnExpression != null));
-			Debug.Assert((queryExpressionJoinClause.EqualsExpression != null));
-			Debug.Assert((queryExpressionJoinClause.Source != null));
-			queryExpressionJoinClause.OnExpression.AcceptVisitor(this, data);
-			queryExpressionJoinClause.EqualsExpression.AcceptVisitor(this, data);
-			return queryExpressionJoinClause.Source.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
-			Debug.Assert((queryExpressionJoinConditionVB != null));
-			Debug.Assert((queryExpressionJoinConditionVB.LeftSide != null));
-			Debug.Assert((queryExpressionJoinConditionVB.RightSide != null));
-			queryExpressionJoinConditionVB.LeftSide.AcceptVisitor(this, data);
-			return queryExpressionJoinConditionVB.RightSide.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
-			Debug.Assert((queryExpressionJoinVBClause != null));
-			Debug.Assert((queryExpressionJoinVBClause.JoinVariable != null));
-			Debug.Assert((queryExpressionJoinVBClause.SubJoin != null));
-			Debug.Assert((queryExpressionJoinVBClause.Conditions != null));
-			queryExpressionJoinVBClause.JoinVariable.AcceptVisitor(this, data);
-			queryExpressionJoinVBClause.SubJoin.AcceptVisitor(this, data);
-			foreach (QueryExpressionJoinConditionVB o in queryExpressionJoinVBClause.Conditions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
-			Debug.Assert((queryExpressionLetClause != null));
-			Debug.Assert((queryExpressionLetClause.Expression != null));
-			return queryExpressionLetClause.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionLetVBClause(QueryExpressionLetVBClause queryExpressionLetVBClause, object data) {
-			Debug.Assert((queryExpressionLetVBClause != null));
-			Debug.Assert((queryExpressionLetVBClause.Variables != null));
-			foreach (ExpressionRangeVariable o in queryExpressionLetVBClause.Variables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
-			Debug.Assert((queryExpressionOrderClause != null));
-			Debug.Assert((queryExpressionOrderClause.Orderings != null));
-			foreach (QueryExpressionOrdering o in queryExpressionOrderClause.Orderings) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
-			Debug.Assert((queryExpressionOrdering != null));
-			Debug.Assert((queryExpressionOrdering.Criteria != null));
-			return queryExpressionOrdering.Criteria.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
-			Debug.Assert((queryExpressionPartitionVBClause != null));
-			Debug.Assert((queryExpressionPartitionVBClause.Expression != null));
-			return queryExpressionPartitionVBClause.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
-			Debug.Assert((queryExpressionSelectClause != null));
-			Debug.Assert((queryExpressionSelectClause.Projection != null));
-			return queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
-			Debug.Assert((queryExpressionSelectVBClause != null));
-			Debug.Assert((queryExpressionSelectVBClause.Variables != null));
-			foreach (ExpressionRangeVariable o in queryExpressionSelectVBClause.Variables) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
-			Debug.Assert((queryExpressionWhereClause != null));
-			Debug.Assert((queryExpressionWhereClause.Condition != null));
-			return queryExpressionWhereClause.Condition.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
-			Debug.Assert((raiseEventStatement != null));
-			Debug.Assert((raiseEventStatement.Arguments != null));
-			foreach (Expression o in raiseEventStatement.Arguments) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
-			Debug.Assert((reDimStatement != null));
-			Debug.Assert((reDimStatement.ReDimClauses != null));
-			foreach (InvocationExpression o in reDimStatement.ReDimClauses) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
-			Debug.Assert((removeHandlerStatement != null));
-			Debug.Assert((removeHandlerStatement.EventExpression != null));
-			Debug.Assert((removeHandlerStatement.HandlerExpression != null));
-			removeHandlerStatement.EventExpression.AcceptVisitor(this, data);
-			return removeHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
-			Debug.Assert((resumeStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitReturnStatement(ReturnStatement returnStatement, object data) {
-			Debug.Assert((returnStatement != null));
-			Debug.Assert((returnStatement.Expression != null));
-			return returnStatement.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitStopStatement(StopStatement stopStatement, object data) {
-			Debug.Assert((stopStatement != null));
-			return null;
-		}
-		
-		public virtual object VisitSwitchSection(SwitchSection switchSection, object data) {
-			Debug.Assert((switchSection != null));
-			Debug.Assert((switchSection.SwitchLabels != null));
-			foreach (CaseLabel o in switchSection.SwitchLabels) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return switchSection.AcceptChildren(this, data);
-		}
-		
-		public virtual object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
-			Debug.Assert((switchStatement != null));
-			Debug.Assert((switchStatement.SwitchExpression != null));
-			Debug.Assert((switchStatement.SwitchSections != null));
-			switchStatement.SwitchExpression.AcceptVisitor(this, data);
-			foreach (SwitchSection o in switchStatement.SwitchSections) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
-			Debug.Assert((templateDefinition != null));
-			Debug.Assert((templateDefinition.Attributes != null));
-			Debug.Assert((templateDefinition.Bases != null));
-			foreach (AttributeSection o in templateDefinition.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (TypeReference o in templateDefinition.Bases) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
-			Debug.Assert((thisReferenceExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitThrowStatement(ThrowStatement throwStatement, object data) {
-			Debug.Assert((throwStatement != null));
-			Debug.Assert((throwStatement.Expression != null));
-			return throwStatement.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
-			Debug.Assert((tryCatchStatement != null));
-			Debug.Assert((tryCatchStatement.StatementBlock != null));
-			Debug.Assert((tryCatchStatement.CatchClauses != null));
-			Debug.Assert((tryCatchStatement.FinallyBlock != null));
-			tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
-			foreach (CatchClause o in tryCatchStatement.CatchClauses) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
-			Debug.Assert((typeDeclaration != null));
-			Debug.Assert((typeDeclaration.Attributes != null));
-			Debug.Assert((typeDeclaration.BaseTypes != null));
-			Debug.Assert((typeDeclaration.Templates != null));
-			foreach (AttributeSection o in typeDeclaration.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (TypeReference o in typeDeclaration.BaseTypes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			foreach (TemplateDefinition o in typeDeclaration.Templates) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return typeDeclaration.AcceptChildren(this, data);
-		}
-		
-		public virtual object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
-			Debug.Assert((typeOfExpression != null));
-			Debug.Assert((typeOfExpression.TypeReference != null));
-			return typeOfExpression.TypeReference.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
-			Debug.Assert((typeOfIsExpression != null));
-			Debug.Assert((typeOfIsExpression.Expression != null));
-			Debug.Assert((typeOfIsExpression.TypeReference != null));
-			typeOfIsExpression.Expression.AcceptVisitor(this, data);
-			return typeOfIsExpression.TypeReference.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitTypeReference(TypeReference typeReference, object data) {
-			Debug.Assert((typeReference != null));
-			Debug.Assert((typeReference.GenericTypes != null));
-			foreach (TypeReference o in typeReference.GenericTypes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
-			Debug.Assert((typeReferenceExpression != null));
-			Debug.Assert((typeReferenceExpression.TypeReference != null));
-			return typeReferenceExpression.TypeReference.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
-			Debug.Assert((unaryOperatorExpression != null));
-			Debug.Assert((unaryOperatorExpression.Expression != null));
-			return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitUsing(Using @using, object data) {
-			Debug.Assert((@using != null));
-			Debug.Assert((@using.Alias != null));
-			return @using.Alias.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
-			Debug.Assert((usingDeclaration != null));
-			Debug.Assert((usingDeclaration.Usings != null));
-			foreach (Using o in usingDeclaration.Usings) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitUsingStatement(UsingStatement usingStatement, object data) {
-			Debug.Assert((usingStatement != null));
-			Debug.Assert((usingStatement.ResourceAcquisition != null));
-			Debug.Assert((usingStatement.EmbeddedStatement != null));
-			usingStatement.ResourceAcquisition.AcceptVisitor(this, data);
-			return usingStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
-			Debug.Assert((variableDeclaration != null));
-			Debug.Assert((variableDeclaration.Initializer != null));
-			Debug.Assert((variableDeclaration.TypeReference != null));
-			Debug.Assert((variableDeclaration.FixedArrayInitialization != null));
-			variableDeclaration.Initializer.AcceptVisitor(this, data);
-			variableDeclaration.TypeReference.AcceptVisitor(this, data);
-			return variableDeclaration.FixedArrayInitialization.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitWithStatement(WithStatement withStatement, object data) {
-			Debug.Assert((withStatement != null));
-			Debug.Assert((withStatement.Expression != null));
-			Debug.Assert((withStatement.Body != null));
-			withStatement.Expression.AcceptVisitor(this, data);
-			return withStatement.Body.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
-			Debug.Assert((xmlAttributeExpression != null));
-			Debug.Assert((xmlAttributeExpression.ExpressionValue != null));
-			return xmlAttributeExpression.ExpressionValue.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
-			Debug.Assert((xmlContentExpression != null));
-			return null;
-		}
-		
-		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
-			Debug.Assert((xmlDocumentExpression != null));
-			Debug.Assert((xmlDocumentExpression.Expressions != null));
-			foreach (XmlExpression o in xmlDocumentExpression.Expressions) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return null;
-		}
-		
-		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
-			Debug.Assert((xmlElementExpression != null));
-			Debug.Assert((xmlElementExpression.Content != null));
-			Debug.Assert((xmlElementExpression.NameExpression != null));
-			Debug.Assert((xmlElementExpression.Attributes != null));
-			xmlElementExpression.Content.AcceptVisitor(this, data);
-			xmlElementExpression.NameExpression.AcceptVisitor(this, data);
-			foreach (XmlExpression o in xmlElementExpression.Attributes) {
-				Debug.Assert(o != null);
-				o.AcceptVisitor(this, data);
-			}
-			return xmlElementExpression.AcceptChildren(this, data);
-		}
-		
-		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
-			Debug.Assert((xmlEmbeddedExpression != null));
-			Debug.Assert((xmlEmbeddedExpression.InlineVBExpression != null));
-			return xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
-		}
-		
-		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
-			Debug.Assert((xmlMemberAccessExpression != null));
-			Debug.Assert((xmlMemberAccessExpression.TargetObject != null));
-			return xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
-		}
-	}
+//	public abstract class AbstractAstVisitor : IAstVisitor {
+//		
+//		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
+//			Debug.Assert((addHandlerStatement != null));
+//			Debug.Assert((addHandlerStatement.EventExpression != null));
+//			Debug.Assert((addHandlerStatement.HandlerExpression != null));
+//			addHandlerStatement.EventExpression.AcceptVisitor(this, data);
+//			return addHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
+//			Debug.Assert((addressOfExpression != null));
+//			Debug.Assert((addressOfExpression.Expression != null));
+//			return addressOfExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
+//			Debug.Assert((arrayCreateExpression != null));
+//			Debug.Assert((arrayCreateExpression.CreateType != null));
+//			Debug.Assert((arrayCreateExpression.Arguments != null));
+//			Debug.Assert((arrayCreateExpression.ArrayInitializer != null));
+//			arrayCreateExpression.CreateType.AcceptVisitor(this, data);
+//			foreach (Expression o in arrayCreateExpression.Arguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return arrayCreateExpression.ArrayInitializer.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
+//			Debug.Assert((assignmentExpression != null));
+//			Debug.Assert((assignmentExpression.Left != null));
+//			Debug.Assert((assignmentExpression.Right != null));
+//			assignmentExpression.Left.AcceptVisitor(this, data);
+//			return assignmentExpression.Right.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
+//			Debug.Assert((attribute != null));
+//			Debug.Assert((attribute.PositionalArguments != null));
+//			Debug.Assert((attribute.NamedArguments != null));
+//			foreach (Expression o in attribute.PositionalArguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (NamedArgumentExpression o in attribute.NamedArguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitAttributeSection(AttributeSection attributeSection, object data) {
+//			Debug.Assert((attributeSection != null));
+//			Debug.Assert((attributeSection.Attributes != null));
+//			foreach (ICSharpCode.NRefactory.VB.Ast.Attribute o in attributeSection.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
+//			Debug.Assert((baseReferenceExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
+//			Debug.Assert((binaryOperatorExpression != null));
+//			Debug.Assert((binaryOperatorExpression.Left != null));
+//			Debug.Assert((binaryOperatorExpression.Right != null));
+//			binaryOperatorExpression.Left.AcceptVisitor(this, data);
+//			return binaryOperatorExpression.Right.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitBlockStatement(BlockStatement blockStatement, object data) {
+//			Debug.Assert((blockStatement != null));
+//			return blockStatement.AcceptChildren(this, data);
+//		}
+//		
+//		public virtual object VisitCaseLabel(CaseLabel caseLabel, object data) {
+//			Debug.Assert((caseLabel != null));
+//			Debug.Assert((caseLabel.Label != null));
+//			Debug.Assert((caseLabel.ToExpression != null));
+//			caseLabel.Label.AcceptVisitor(this, data);
+//			return caseLabel.ToExpression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitCastExpression(CastExpression castExpression, object data) {
+//			Debug.Assert((castExpression != null));
+//			Debug.Assert((castExpression.CastTo != null));
+//			Debug.Assert((castExpression.Expression != null));
+//			castExpression.CastTo.AcceptVisitor(this, data);
+//			return castExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitCatchClause(CatchClause catchClause, object data) {
+//			Debug.Assert((catchClause != null));
+//			Debug.Assert((catchClause.TypeReference != null));
+//			Debug.Assert((catchClause.StatementBlock != null));
+//			Debug.Assert((catchClause.Condition != null));
+//			catchClause.TypeReference.AcceptVisitor(this, data);
+//			catchClause.StatementBlock.AcceptVisitor(this, data);
+//			return catchClause.Condition.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
+//			Debug.Assert((classReferenceExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
+//			Debug.Assert((collectionInitializerExpression != null));
+//			Debug.Assert((collectionInitializerExpression.CreateExpressions != null));
+//			foreach (Expression o in collectionInitializerExpression.CreateExpressions) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
+//			Debug.Assert((collectionRangeVariable != null));
+//			Debug.Assert((collectionRangeVariable.Expression != null));
+//			Debug.Assert((collectionRangeVariable.Type != null));
+//			collectionRangeVariable.Expression.AcceptVisitor(this, data);
+//			return collectionRangeVariable.Type.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
+//			Debug.Assert((compilationUnit != null));
+//			return compilationUnit.AcceptChildren(this, data);
+//		}
+//		
+//		public virtual object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
+//			Debug.Assert((conditionalExpression != null));
+//			Debug.Assert((conditionalExpression.Condition != null));
+//			Debug.Assert((conditionalExpression.TrueExpression != null));
+//			Debug.Assert((conditionalExpression.FalseExpression != null));
+//			conditionalExpression.Condition.AcceptVisitor(this, data);
+//			conditionalExpression.TrueExpression.AcceptVisitor(this, data);
+//			return conditionalExpression.FalseExpression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
+//			Debug.Assert((constructorDeclaration != null));
+//			Debug.Assert((constructorDeclaration.Attributes != null));
+//			Debug.Assert((constructorDeclaration.Parameters != null));
+//			Debug.Assert((constructorDeclaration.ConstructorInitializer != null));
+//			Debug.Assert((constructorDeclaration.Body != null));
+//			foreach (AttributeSection o in constructorDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ParameterDeclarationExpression o in constructorDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			constructorDeclaration.ConstructorInitializer.AcceptVisitor(this, data);
+//			return constructorDeclaration.Body.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
+//			Debug.Assert((constructorInitializer != null));
+//			Debug.Assert((constructorInitializer.Arguments != null));
+//			foreach (Expression o in constructorInitializer.Arguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitContinueStatement(ContinueStatement continueStatement, object data) {
+//			Debug.Assert((continueStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
+//			Debug.Assert((declareDeclaration != null));
+//			Debug.Assert((declareDeclaration.Attributes != null));
+//			Debug.Assert((declareDeclaration.Parameters != null));
+//			Debug.Assert((declareDeclaration.TypeReference != null));
+//			foreach (AttributeSection o in declareDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ParameterDeclarationExpression o in declareDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return declareDeclaration.TypeReference.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
+//			Debug.Assert((defaultValueExpression != null));
+//			Debug.Assert((defaultValueExpression.TypeReference != null));
+//			return defaultValueExpression.TypeReference.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
+//			Debug.Assert((delegateDeclaration != null));
+//			Debug.Assert((delegateDeclaration.Attributes != null));
+//			Debug.Assert((delegateDeclaration.ReturnType != null));
+//			Debug.Assert((delegateDeclaration.Parameters != null));
+//			Debug.Assert((delegateDeclaration.Templates != null));
+//			foreach (AttributeSection o in delegateDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			delegateDeclaration.ReturnType.AcceptVisitor(this, data);
+//			foreach (ParameterDeclarationExpression o in delegateDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (TemplateDefinition o in delegateDeclaration.Templates) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
+//			Debug.Assert((directionExpression != null));
+//			Debug.Assert((directionExpression.Expression != null));
+//			return directionExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
+//			Debug.Assert((doLoopStatement != null));
+//			Debug.Assert((doLoopStatement.Condition != null));
+//			Debug.Assert((doLoopStatement.EmbeddedStatement != null));
+//			doLoopStatement.Condition.AcceptVisitor(this, data);
+//			return doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
+//			Debug.Assert((elseIfSection != null));
+//			Debug.Assert((elseIfSection.Condition != null));
+//			Debug.Assert((elseIfSection.EmbeddedStatement != null));
+//			elseIfSection.Condition.AcceptVisitor(this, data);
+//			return elseIfSection.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitEndStatement(EndStatement endStatement, object data) {
+//			Debug.Assert((endStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitEraseStatement(EraseStatement eraseStatement, object data) {
+//			Debug.Assert((eraseStatement != null));
+//			Debug.Assert((eraseStatement.Expressions != null));
+//			foreach (Expression o in eraseStatement.Expressions) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitErrorStatement(ErrorStatement errorStatement, object data) {
+//			Debug.Assert((errorStatement != null));
+//			Debug.Assert((errorStatement.Expression != null));
+//			return errorStatement.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
+//			Debug.Assert((eventAddRegion != null));
+//			Debug.Assert((eventAddRegion.Attributes != null));
+//			Debug.Assert((eventAddRegion.Block != null));
+//			Debug.Assert((eventAddRegion.Parameters != null));
+//			foreach (AttributeSection o in eventAddRegion.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			eventAddRegion.Block.AcceptVisitor(this, data);
+//			foreach (ParameterDeclarationExpression o in eventAddRegion.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
+//			Debug.Assert((eventDeclaration != null));
+//			Debug.Assert((eventDeclaration.Attributes != null));
+//			Debug.Assert((eventDeclaration.Parameters != null));
+//			Debug.Assert((eventDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((eventDeclaration.TypeReference != null));
+//			Debug.Assert((eventDeclaration.AddRegion != null));
+//			Debug.Assert((eventDeclaration.RemoveRegion != null));
+//			Debug.Assert((eventDeclaration.RaiseRegion != null));
+//			Debug.Assert((eventDeclaration.Initializer != null));
+//			foreach (AttributeSection o in eventDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ParameterDeclarationExpression o in eventDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (InterfaceImplementation o in eventDeclaration.InterfaceImplementations) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			eventDeclaration.TypeReference.AcceptVisitor(this, data);
+//			eventDeclaration.AddRegion.AcceptVisitor(this, data);
+//			eventDeclaration.RemoveRegion.AcceptVisitor(this, data);
+//			eventDeclaration.RaiseRegion.AcceptVisitor(this, data);
+//			return eventDeclaration.Initializer.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
+//			Debug.Assert((eventRaiseRegion != null));
+//			Debug.Assert((eventRaiseRegion.Attributes != null));
+//			Debug.Assert((eventRaiseRegion.Block != null));
+//			Debug.Assert((eventRaiseRegion.Parameters != null));
+//			foreach (AttributeSection o in eventRaiseRegion.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			eventRaiseRegion.Block.AcceptVisitor(this, data);
+//			foreach (ParameterDeclarationExpression o in eventRaiseRegion.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
+//			Debug.Assert((eventRemoveRegion != null));
+//			Debug.Assert((eventRemoveRegion.Attributes != null));
+//			Debug.Assert((eventRemoveRegion.Block != null));
+//			Debug.Assert((eventRemoveRegion.Parameters != null));
+//			foreach (AttributeSection o in eventRemoveRegion.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			eventRemoveRegion.Block.AcceptVisitor(this, data);
+//			foreach (ParameterDeclarationExpression o in eventRemoveRegion.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitExitStatement(ExitStatement exitStatement, object data) {
+//			Debug.Assert((exitStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
+//			Debug.Assert((expressionRangeVariable != null));
+//			Debug.Assert((expressionRangeVariable.Expression != null));
+//			Debug.Assert((expressionRangeVariable.Type != null));
+//			expressionRangeVariable.Expression.AcceptVisitor(this, data);
+//			return expressionRangeVariable.Type.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
+//			Debug.Assert((expressionStatement != null));
+//			Debug.Assert((expressionStatement.Expression != null));
+//			return expressionStatement.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
+//			Debug.Assert((externAliasDirective != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
+//			Debug.Assert((fieldDeclaration != null));
+//			Debug.Assert((fieldDeclaration.Attributes != null));
+//			Debug.Assert((fieldDeclaration.TypeReference != null));
+//			Debug.Assert((fieldDeclaration.Fields != null));
+//			foreach (AttributeSection o in fieldDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			fieldDeclaration.TypeReference.AcceptVisitor(this, data);
+//			foreach (VariableDeclaration o in fieldDeclaration.Fields) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
+//			Debug.Assert((foreachStatement != null));
+//			Debug.Assert((foreachStatement.TypeReference != null));
+//			Debug.Assert((foreachStatement.Expression != null));
+//			Debug.Assert((foreachStatement.NextExpression != null));
+//			Debug.Assert((foreachStatement.EmbeddedStatement != null));
+//			foreachStatement.TypeReference.AcceptVisitor(this, data);
+//			foreachStatement.Expression.AcceptVisitor(this, data);
+//			foreachStatement.NextExpression.AcceptVisitor(this, data);
+//			return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
+//			Debug.Assert((forNextStatement != null));
+//			Debug.Assert((forNextStatement.Start != null));
+//			Debug.Assert((forNextStatement.End != null));
+//			Debug.Assert((forNextStatement.Step != null));
+//			Debug.Assert((forNextStatement.NextExpressions != null));
+//			Debug.Assert((forNextStatement.TypeReference != null));
+//			Debug.Assert((forNextStatement.LoopVariableExpression != null));
+//			Debug.Assert((forNextStatement.EmbeddedStatement != null));
+//			forNextStatement.Start.AcceptVisitor(this, data);
+//			forNextStatement.End.AcceptVisitor(this, data);
+//			forNextStatement.Step.AcceptVisitor(this, data);
+//			foreach (Expression o in forNextStatement.NextExpressions) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			forNextStatement.TypeReference.AcceptVisitor(this, data);
+//			forNextStatement.LoopVariableExpression.AcceptVisitor(this, data);
+//			return forNextStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitGotoStatement(GotoStatement gotoStatement, object data) {
+//			Debug.Assert((gotoStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitIdentifierExpression(SimpleNameExpression identifierExpression, object data) {
+//			Debug.Assert((identifierExpression != null));
+//			Debug.Assert((identifierExpression.TypeArguments != null));
+//			foreach (TypeReference o in identifierExpression.TypeArguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
+//			Debug.Assert((ifElseStatement != null));
+//			Debug.Assert((ifElseStatement.Condition != null));
+//			Debug.Assert((ifElseStatement.TrueStatement != null));
+//			Debug.Assert((ifElseStatement.FalseStatement != null));
+//			Debug.Assert((ifElseStatement.ElseIfSections != null));
+//			ifElseStatement.Condition.AcceptVisitor(this, data);
+//			foreach (Statement o in ifElseStatement.TrueStatement) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (Statement o in ifElseStatement.FalseStatement) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ElseIfSection o in ifElseStatement.ElseIfSections) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
+//			Debug.Assert((innerClassTypeReference != null));
+//			Debug.Assert((innerClassTypeReference.GenericTypes != null));
+//			Debug.Assert((innerClassTypeReference.BaseType != null));
+//			foreach (TypeReference o in innerClassTypeReference.GenericTypes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return innerClassTypeReference.BaseType.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
+//			Debug.Assert((interfaceImplementation != null));
+//			Debug.Assert((interfaceImplementation.InterfaceType != null));
+//			return interfaceImplementation.InterfaceType.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
+//			Debug.Assert((invocationExpression != null));
+//			Debug.Assert((invocationExpression.TargetObject != null));
+//			Debug.Assert((invocationExpression.Arguments != null));
+//			invocationExpression.TargetObject.AcceptVisitor(this, data);
+//			foreach (Expression o in invocationExpression.Arguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitLabelStatement(LabelStatement labelStatement, object data) {
+//			Debug.Assert((labelStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
+//			Debug.Assert((lambdaExpression != null));
+//			Debug.Assert((lambdaExpression.Parameters != null));
+//			Debug.Assert((lambdaExpression.StatementBody != null));
+//			Debug.Assert((lambdaExpression.ExpressionBody != null));
+//			Debug.Assert((lambdaExpression.ReturnType != null));
+//			foreach (ParameterDeclarationExpression o in lambdaExpression.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			lambdaExpression.StatementBody.AcceptVisitor(this, data);
+//			lambdaExpression.ExpressionBody.AcceptVisitor(this, data);
+//			return lambdaExpression.ReturnType.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
+//			Debug.Assert((localVariableDeclaration != null));
+//			Debug.Assert((localVariableDeclaration.TypeReference != null));
+//			Debug.Assert((localVariableDeclaration.Variables != null));
+//			localVariableDeclaration.TypeReference.AcceptVisitor(this, data);
+//			foreach (VariableDeclaration o in localVariableDeclaration.Variables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitLockStatement(LockStatement lockStatement, object data) {
+//			Debug.Assert((lockStatement != null));
+//			Debug.Assert((lockStatement.LockExpression != null));
+//			Debug.Assert((lockStatement.EmbeddedStatement != null));
+//			lockStatement.LockExpression.AcceptVisitor(this, data);
+//			return lockStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
+//			Debug.Assert((memberInitializerExpression != null));
+//			Debug.Assert((memberInitializerExpression.Expression != null));
+//			return memberInitializerExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
+//			Debug.Assert((memberReferenceExpression != null));
+//			Debug.Assert((memberReferenceExpression.TargetObject != null));
+//			Debug.Assert((memberReferenceExpression.TypeArguments != null));
+//			memberReferenceExpression.TargetObject.AcceptVisitor(this, data);
+//			foreach (TypeReference o in memberReferenceExpression.TypeArguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
+//			Debug.Assert((methodDeclaration != null));
+//			Debug.Assert((methodDeclaration.Attributes != null));
+//			Debug.Assert((methodDeclaration.Parameters != null));
+//			Debug.Assert((methodDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((methodDeclaration.TypeReference != null));
+//			Debug.Assert((methodDeclaration.Body != null));
+//			Debug.Assert((methodDeclaration.Templates != null));
+//			foreach (AttributeSection o in methodDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ParameterDeclarationExpression o in methodDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (InterfaceImplementation o in methodDeclaration.InterfaceImplementations) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			methodDeclaration.TypeReference.AcceptVisitor(this, data);
+//			methodDeclaration.Body.AcceptVisitor(this, data);
+//			foreach (TemplateDefinition o in methodDeclaration.Templates) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
+//			Debug.Assert((namedArgumentExpression != null));
+//			Debug.Assert((namedArgumentExpression.Expression != null));
+//			return namedArgumentExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
+//			Debug.Assert((namespaceDeclaration != null));
+//			return namespaceDeclaration.AcceptChildren(this, data);
+//		}
+//		
+//		public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
+//			Debug.Assert((objectCreateExpression != null));
+//			Debug.Assert((objectCreateExpression.CreateType != null));
+//			Debug.Assert((objectCreateExpression.Parameters != null));
+//			Debug.Assert((objectCreateExpression.ObjectInitializer != null));
+//			objectCreateExpression.CreateType.AcceptVisitor(this, data);
+//			foreach (Expression o in objectCreateExpression.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return objectCreateExpression.ObjectInitializer.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
+//			Debug.Assert((onErrorStatement != null));
+//			Debug.Assert((onErrorStatement.EmbeddedStatement != null));
+//			return onErrorStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
+//			Debug.Assert((operatorDeclaration != null));
+//			Debug.Assert((operatorDeclaration.Attributes != null));
+//			Debug.Assert((operatorDeclaration.Parameters != null));
+//			Debug.Assert((operatorDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((operatorDeclaration.TypeReference != null));
+//			Debug.Assert((operatorDeclaration.Body != null));
+//			Debug.Assert((operatorDeclaration.Templates != null));
+//			foreach (AttributeSection o in operatorDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ParameterDeclarationExpression o in operatorDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (InterfaceImplementation o in operatorDeclaration.InterfaceImplementations) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			operatorDeclaration.TypeReference.AcceptVisitor(this, data);
+//			operatorDeclaration.Body.AcceptVisitor(this, data);
+//			foreach (TemplateDefinition o in operatorDeclaration.Templates) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
+//			Debug.Assert((optionDeclaration != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
+//			Debug.Assert((parameterDeclarationExpression != null));
+//			Debug.Assert((parameterDeclarationExpression.Attributes != null));
+//			Debug.Assert((parameterDeclarationExpression.TypeReference != null));
+//			Debug.Assert((parameterDeclarationExpression.DefaultValue != null));
+//			foreach (AttributeSection o in parameterDeclarationExpression.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			parameterDeclarationExpression.TypeReference.AcceptVisitor(this, data);
+//			return parameterDeclarationExpression.DefaultValue.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
+//			Debug.Assert((parenthesizedExpression != null));
+//			Debug.Assert((parenthesizedExpression.Expression != null));
+//			return parenthesizedExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
+//			Debug.Assert((primitiveExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
+//			Debug.Assert((propertyDeclaration != null));
+//			Debug.Assert((propertyDeclaration.Attributes != null));
+//			Debug.Assert((propertyDeclaration.Parameters != null));
+//			Debug.Assert((propertyDeclaration.InterfaceImplementations != null));
+//			Debug.Assert((propertyDeclaration.TypeReference != null));
+//			Debug.Assert((propertyDeclaration.GetRegion != null));
+//			Debug.Assert((propertyDeclaration.SetRegion != null));
+//			Debug.Assert((propertyDeclaration.Initializer != null));
+//			foreach (AttributeSection o in propertyDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ParameterDeclarationExpression o in propertyDeclaration.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (InterfaceImplementation o in propertyDeclaration.InterfaceImplementations) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			propertyDeclaration.TypeReference.AcceptVisitor(this, data);
+//			propertyDeclaration.GetRegion.AcceptVisitor(this, data);
+//			propertyDeclaration.SetRegion.AcceptVisitor(this, data);
+//			return propertyDeclaration.Initializer.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
+//			Debug.Assert((propertyGetRegion != null));
+//			Debug.Assert((propertyGetRegion.Attributes != null));
+//			Debug.Assert((propertyGetRegion.Block != null));
+//			foreach (AttributeSection o in propertyGetRegion.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return propertyGetRegion.Block.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
+//			Debug.Assert((propertySetRegion != null));
+//			Debug.Assert((propertySetRegion.Attributes != null));
+//			Debug.Assert((propertySetRegion.Block != null));
+//			Debug.Assert((propertySetRegion.Parameters != null));
+//			foreach (AttributeSection o in propertySetRegion.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			propertySetRegion.Block.AcceptVisitor(this, data);
+//			foreach (ParameterDeclarationExpression o in propertySetRegion.Parameters) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
+//			Debug.Assert((queryExpression != null));
+//			Debug.Assert((queryExpression.Clauses != null));
+//			foreach (QueryExpressionClause o in queryExpression.Clauses) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
+//			Debug.Assert((queryExpressionAggregateClause != null));
+//			Debug.Assert((queryExpressionAggregateClause.Source != null));
+//			Debug.Assert((queryExpressionAggregateClause.MiddleClauses != null));
+//			Debug.Assert((queryExpressionAggregateClause.IntoVariables != null));
+//			queryExpressionAggregateClause.Source.AcceptVisitor(this, data);
+//			foreach (QueryExpressionClause o in queryExpressionAggregateClause.MiddleClauses) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ExpressionRangeVariable o in queryExpressionAggregateClause.IntoVariables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
+//			Debug.Assert((queryExpressionDistinctClause != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
+//			Debug.Assert((queryExpressionFromClause != null));
+//			Debug.Assert((queryExpressionFromClause.Sources != null));
+//			foreach (CollectionRangeVariable o in queryExpressionFromClause.Sources) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
+//			Debug.Assert((queryExpressionGroupClause != null));
+//			Debug.Assert((queryExpressionGroupClause.Projection != null));
+//			Debug.Assert((queryExpressionGroupClause.GroupBy != null));
+//			queryExpressionGroupClause.Projection.AcceptVisitor(this, data);
+//			return queryExpressionGroupClause.GroupBy.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
+//			Debug.Assert((queryExpressionGroupJoinVBClause != null));
+//			Debug.Assert((queryExpressionGroupJoinVBClause.JoinClause != null));
+//			Debug.Assert((queryExpressionGroupJoinVBClause.IntoVariables != null));
+//			queryExpressionGroupJoinVBClause.JoinClause.AcceptVisitor(this, data);
+//			foreach (ExpressionRangeVariable o in queryExpressionGroupJoinVBClause.IntoVariables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
+//			Debug.Assert((queryExpressionGroupVBClause != null));
+//			Debug.Assert((queryExpressionGroupVBClause.GroupVariables != null));
+//			Debug.Assert((queryExpressionGroupVBClause.ByVariables != null));
+//			Debug.Assert((queryExpressionGroupVBClause.IntoVariables != null));
+//			foreach (ExpressionRangeVariable o in queryExpressionGroupVBClause.GroupVariables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ExpressionRangeVariable o in queryExpressionGroupVBClause.ByVariables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (ExpressionRangeVariable o in queryExpressionGroupVBClause.IntoVariables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
+//			Debug.Assert((queryExpressionJoinClause != null));
+//			Debug.Assert((queryExpressionJoinClause.OnExpression != null));
+//			Debug.Assert((queryExpressionJoinClause.EqualsExpression != null));
+//			Debug.Assert((queryExpressionJoinClause.Source != null));
+//			queryExpressionJoinClause.OnExpression.AcceptVisitor(this, data);
+//			queryExpressionJoinClause.EqualsExpression.AcceptVisitor(this, data);
+//			return queryExpressionJoinClause.Source.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
+//			Debug.Assert((queryExpressionJoinConditionVB != null));
+//			Debug.Assert((queryExpressionJoinConditionVB.LeftSide != null));
+//			Debug.Assert((queryExpressionJoinConditionVB.RightSide != null));
+//			queryExpressionJoinConditionVB.LeftSide.AcceptVisitor(this, data);
+//			return queryExpressionJoinConditionVB.RightSide.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
+//			Debug.Assert((queryExpressionJoinVBClause != null));
+//			Debug.Assert((queryExpressionJoinVBClause.JoinVariable != null));
+//			Debug.Assert((queryExpressionJoinVBClause.SubJoin != null));
+//			Debug.Assert((queryExpressionJoinVBClause.Conditions != null));
+//			queryExpressionJoinVBClause.JoinVariable.AcceptVisitor(this, data);
+//			queryExpressionJoinVBClause.SubJoin.AcceptVisitor(this, data);
+//			foreach (QueryExpressionJoinConditionVB o in queryExpressionJoinVBClause.Conditions) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
+//			Debug.Assert((queryExpressionLetClause != null));
+//			Debug.Assert((queryExpressionLetClause.Expression != null));
+//			return queryExpressionLetClause.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionLetVBClause(QueryExpressionLetClause queryExpressionLetVBClause, object data) {
+//			Debug.Assert((queryExpressionLetVBClause != null));
+//			Debug.Assert((queryExpressionLetVBClause.Variables != null));
+//			foreach (ExpressionRangeVariable o in queryExpressionLetVBClause.Variables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
+//			Debug.Assert((queryExpressionOrderClause != null));
+//			Debug.Assert((queryExpressionOrderClause.Orderings != null));
+//			foreach (QueryExpressionOrdering o in queryExpressionOrderClause.Orderings) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
+//			Debug.Assert((queryExpressionOrdering != null));
+//			Debug.Assert((queryExpressionOrdering.Criteria != null));
+//			return queryExpressionOrdering.Criteria.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
+//			Debug.Assert((queryExpressionPartitionVBClause != null));
+//			Debug.Assert((queryExpressionPartitionVBClause.Expression != null));
+//			return queryExpressionPartitionVBClause.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
+//			Debug.Assert((queryExpressionSelectClause != null));
+//			Debug.Assert((queryExpressionSelectClause.Projection != null));
+//			return queryExpressionSelectClause.Projection.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
+//			Debug.Assert((queryExpressionSelectVBClause != null));
+//			Debug.Assert((queryExpressionSelectVBClause.Variables != null));
+//			foreach (ExpressionRangeVariable o in queryExpressionSelectVBClause.Variables) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
+//			Debug.Assert((queryExpressionWhereClause != null));
+//			Debug.Assert((queryExpressionWhereClause.Condition != null));
+//			return queryExpressionWhereClause.Condition.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
+//			Debug.Assert((raiseEventStatement != null));
+//			Debug.Assert((raiseEventStatement.Arguments != null));
+//			foreach (Expression o in raiseEventStatement.Arguments) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
+//			Debug.Assert((reDimStatement != null));
+//			Debug.Assert((reDimStatement.ReDimClauses != null));
+//			foreach (InvocationExpression o in reDimStatement.ReDimClauses) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
+//			Debug.Assert((removeHandlerStatement != null));
+//			Debug.Assert((removeHandlerStatement.EventExpression != null));
+//			Debug.Assert((removeHandlerStatement.HandlerExpression != null));
+//			removeHandlerStatement.EventExpression.AcceptVisitor(this, data);
+//			return removeHandlerStatement.HandlerExpression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
+//			Debug.Assert((resumeStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitReturnStatement(ReturnStatement returnStatement, object data) {
+//			Debug.Assert((returnStatement != null));
+//			Debug.Assert((returnStatement.Expression != null));
+//			return returnStatement.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitStopStatement(StopStatement stopStatement, object data) {
+//			Debug.Assert((stopStatement != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitSwitchSection(SwitchSection switchSection, object data) {
+//			Debug.Assert((switchSection != null));
+//			Debug.Assert((switchSection.SwitchLabels != null));
+//			foreach (CaseLabel o in switchSection.SwitchLabels) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return switchSection.AcceptChildren(this, data);
+//		}
+//		
+//		public virtual object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
+//			Debug.Assert((switchStatement != null));
+//			Debug.Assert((switchStatement.SwitchExpression != null));
+//			Debug.Assert((switchStatement.SwitchSections != null));
+//			switchStatement.SwitchExpression.AcceptVisitor(this, data);
+//			foreach (SwitchSection o in switchStatement.SwitchSections) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
+//			Debug.Assert((templateDefinition != null));
+//			Debug.Assert((templateDefinition.Attributes != null));
+//			Debug.Assert((templateDefinition.Bases != null));
+//			foreach (AttributeSection o in templateDefinition.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (TypeReference o in templateDefinition.Bases) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
+//			Debug.Assert((thisReferenceExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitThrowStatement(ThrowStatement throwStatement, object data) {
+//			Debug.Assert((throwStatement != null));
+//			Debug.Assert((throwStatement.Expression != null));
+//			return throwStatement.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
+//			Debug.Assert((tryCatchStatement != null));
+//			Debug.Assert((tryCatchStatement.StatementBlock != null));
+//			Debug.Assert((tryCatchStatement.CatchClauses != null));
+//			Debug.Assert((tryCatchStatement.FinallyBlock != null));
+//			tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
+//			foreach (CatchClause o in tryCatchStatement.CatchClauses) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
+//			Debug.Assert((typeDeclaration != null));
+//			Debug.Assert((typeDeclaration.Attributes != null));
+//			Debug.Assert((typeDeclaration.BaseTypes != null));
+//			Debug.Assert((typeDeclaration.Templates != null));
+//			foreach (AttributeSection o in typeDeclaration.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (TypeReference o in typeDeclaration.BaseTypes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			foreach (TemplateDefinition o in typeDeclaration.Templates) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return typeDeclaration.AcceptChildren(this, data);
+//		}
+//		
+//		public virtual object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
+//			Debug.Assert((typeOfExpression != null));
+//			Debug.Assert((typeOfExpression.TypeReference != null));
+//			return typeOfExpression.TypeReference.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
+//			Debug.Assert((typeOfIsExpression != null));
+//			Debug.Assert((typeOfIsExpression.Expression != null));
+//			Debug.Assert((typeOfIsExpression.TypeReference != null));
+//			typeOfIsExpression.Expression.AcceptVisitor(this, data);
+//			return typeOfIsExpression.TypeReference.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitTypeReference(TypeReference typeReference, object data) {
+//			Debug.Assert((typeReference != null));
+//			Debug.Assert((typeReference.GenericTypes != null));
+//			foreach (TypeReference o in typeReference.GenericTypes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
+//			Debug.Assert((typeReferenceExpression != null));
+//			Debug.Assert((typeReferenceExpression.TypeReference != null));
+//			return typeReferenceExpression.TypeReference.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
+//			Debug.Assert((unaryOperatorExpression != null));
+//			Debug.Assert((unaryOperatorExpression.Expression != null));
+//			return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitUsing(ImportsClause @using, object data) {
+//			Debug.Assert((@using != null));
+//			Debug.Assert((@using.Alias != null));
+//			return @using.Alias.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitUsingDeclaration(ImportsStatement usingDeclaration, object data) {
+//			Debug.Assert((usingDeclaration != null));
+//			Debug.Assert((usingDeclaration.ImportsClauses != null));
+//			foreach (ImportsClause o in usingDeclaration.ImportsClauses) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitUsingStatement(UsingStatement usingStatement, object data) {
+//			Debug.Assert((usingStatement != null));
+//			Debug.Assert((usingStatement.ResourceAcquisition != null));
+//			Debug.Assert((usingStatement.EmbeddedStatement != null));
+//			usingStatement.ResourceAcquisition.AcceptVisitor(this, data);
+//			return usingStatement.EmbeddedStatement.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
+//			Debug.Assert((variableDeclaration != null));
+//			Debug.Assert((variableDeclaration.Initializer != null));
+//			Debug.Assert((variableDeclaration.TypeReference != null));
+//			Debug.Assert((variableDeclaration.FixedArrayInitialization != null));
+//			variableDeclaration.Initializer.AcceptVisitor(this, data);
+//			variableDeclaration.TypeReference.AcceptVisitor(this, data);
+//			return variableDeclaration.FixedArrayInitialization.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitWithStatement(WithStatement withStatement, object data) {
+//			Debug.Assert((withStatement != null));
+//			Debug.Assert((withStatement.Expression != null));
+//			Debug.Assert((withStatement.Body != null));
+//			withStatement.Expression.AcceptVisitor(this, data);
+//			return withStatement.Body.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
+//			Debug.Assert((xmlAttributeExpression != null));
+//			Debug.Assert((xmlAttributeExpression.ExpressionValue != null));
+//			return xmlAttributeExpression.ExpressionValue.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+//			Debug.Assert((xmlContentExpression != null));
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+//			Debug.Assert((xmlDocumentExpression != null));
+//			Debug.Assert((xmlDocumentExpression.Expressions != null));
+//			foreach (XmlExpression o in xmlDocumentExpression.Expressions) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return null;
+//		}
+//		
+//		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+//			Debug.Assert((xmlElementExpression != null));
+//			Debug.Assert((xmlElementExpression.Content != null));
+//			Debug.Assert((xmlElementExpression.NameExpression != null));
+//			Debug.Assert((xmlElementExpression.Attributes != null));
+//			xmlElementExpression.Content.AcceptVisitor(this, data);
+//			xmlElementExpression.NameExpression.AcceptVisitor(this, data);
+//			foreach (XmlExpression o in xmlElementExpression.Attributes) {
+//				Debug.Assert(o != null);
+//				o.AcceptVisitor(this, data);
+//			}
+//			return xmlElementExpression.AcceptChildren(this, data);
+//		}
+//		
+//		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+//			Debug.Assert((xmlEmbeddedExpression != null));
+//			Debug.Assert((xmlEmbeddedExpression.InlineVBExpression != null));
+//			return xmlEmbeddedExpression.InlineVBExpression.AcceptVisitor(this, data);
+//		}
+//		
+//		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
+//			Debug.Assert((xmlMemberAccessExpression != null));
+//			Debug.Assert((xmlMemberAccessExpression.TargetObject != null));
+//			return xmlMemberAccessExpression.TargetObject.AcceptVisitor(this, data);
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs
deleted file mode 100644
index b63a86f85..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CodeDOMOutputVisitor.cs
+++ /dev/null
@@ -1,1534 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.CodeDom;
-using System.Collections;
-using System.Collections.Generic;
-using System.Reflection;
-using System.Text;
-
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	public class CodeDomVisitor : AbstractAstVisitor
-	{
-		Stack<CodeNamespace>  namespaceDeclarations = new Stack<CodeNamespace>();
-		Stack<CodeTypeDeclaration> typeDeclarations = new Stack<CodeTypeDeclaration>();
-		Stack<CodeStatementCollection> codeStack    = new Stack<CodeStatementCollection>();
-		List<CodeVariableDeclarationStatement> variables = new List<CodeVariableDeclarationStatement>();
-		List<CodeParameterDeclarationExpression> parameters = new List<CodeParameterDeclarationExpression>();
-		Stack<Breakable> breakableStack = new Stack<Breakable>();
-		
-		TypeDeclaration currentTypeDeclaration = null;
-		
-		IEnvironmentInformationProvider environmentInformationProvider = DummyEnvironmentInformationProvider.Instance;
-
-		// track break and continue statements
-		class Breakable
-		{
-			public static int NextId = 0;
-
-			public int Id = 0;
-			public bool IsBreak = false;
-			public bool IsContinue = false;
-			public bool AllowContinue = true;
-
-			public Breakable()
-			{
-				Id = ++NextId;
-			}
-
-			public Breakable(bool allowContinue)
-				: this()
-			{
-				AllowContinue = allowContinue;
-			}
-		}
-
-		public IEnvironmentInformationProvider EnvironmentInformationProvider {
-			get { return environmentInformationProvider; }
-			set {
-				if (value == null)
-					throw new ArgumentNullException("value");
-				environmentInformationProvider = value;
-			}
-		}
-		
-		// dummy collection used to swallow statements
-		CodeStatementCollection NullStmtCollection = new CodeStatementCollection();
-		
-		public CodeCompileUnit codeCompileUnit   = new CodeCompileUnit();
-
-		// RG
-		//
-		// Initialise Scope Variables for Current Method
-		void InitMethodScope()
-		{
-			usingId = 0;
-			foreachId = 0;
-			switchId = 0;
-			doId = 0;
-			Breakable.NextId = 0;
-			variables.Clear();
-			parameters.Clear();
-		}
-		
-		string GetDotNetNameFromTypeReference(TypeReference type)
-		{
-			string name;
-			InnerClassTypeReference ictr = type as InnerClassTypeReference;
-			if (ictr != null) {
-				name = GetDotNetNameFromTypeReference(ictr.BaseType) + "+" + ictr.Type;
-			} else {
-				name = type.Type;
-			}
-			if (type.GenericTypes.Count != 0)
-				name = name + "`" + type.GenericTypes.Count.ToString();
-			return name;
-		}
-		
-		CodeTypeReference ConvType(TypeReference type)
-		{
-			if (type == null) {
-				throw new ArgumentNullException("type");
-			}
-			
-			CodeTypeReference t = new CodeTypeReference(GetDotNetNameFromTypeReference(type));
-			InnerClassTypeReference ictr = type as InnerClassTypeReference;
-			if (ictr != null) {
-				type = ictr.CombineToNormalTypeReference();
-			}
-			foreach (TypeReference gt in type.GenericTypes) {
-				t.TypeArguments.Add(ConvType(gt));
-			}
-			if (type.IsArrayType) {
-				for (int i = type.RankSpecifier.Length - 1; i >= 0; --i)
-				{
-					t = new CodeTypeReference(t, type.RankSpecifier[i] + 1);
-				}
-			}
-			
-			return t;
-		}
-		
-		void AddStmt(CodeStatement stmt)
-		{
-			if (codeStack.Count == 0)
-				return;
-			CodeStatementCollection stmtCollection = codeStack.Peek();
-			if (stmtCollection != null) {
-				stmtCollection.Add(stmt);
-			}
-		}
-		
-		static MemberAttributes ConvMemberAttributes(Modifiers modifier)
-		{
-			MemberAttributes attr = (MemberAttributes)0;
-			
-			if ((modifier & Modifiers.Abstract) != 0)
-				attr |=  MemberAttributes.Abstract;
-			if ((modifier & Modifiers.Const) != 0)
-				attr |=  MemberAttributes.Const;
-			if ((modifier & Modifiers.Sealed) != 0)
-				attr |=  MemberAttributes.Final;
-			if ((modifier & Modifiers.New) != 0)
-				attr |=  MemberAttributes.New;
-			if ((modifier & Modifiers.Virtual) != 0)
-				attr |=  MemberAttributes.Overloaded;
-			if ((modifier & Modifiers.Override) != 0)
-				attr |=  MemberAttributes.Override;
-			if ((modifier & Modifiers.Static) != 0)
-				attr |=  MemberAttributes.Static;
-			
-			if ((modifier & Modifiers.Public) != 0)
-				attr |=  MemberAttributes.Public;
-			else if ((modifier & Modifiers.Internal) != 0 && (modifier & Modifiers.Protected) != 0)
-				attr |=  MemberAttributes.FamilyOrAssembly;
-			else if ((modifier & Modifiers.Internal) != 0)
-				attr |=  MemberAttributes.Assembly;
-			else if ((modifier & Modifiers.Protected) != 0)
-				attr |=  MemberAttributes.Family;
-			else if ((modifier & Modifiers.Private) != 0)
-				attr |= MemberAttributes.Private;
-			
-			return attr;
-		}
-		
-		static TypeAttributes ConvTypeAttributes(Modifiers modifier)
-		{
-			TypeAttributes attr = (TypeAttributes)0;
-			if ((modifier & Modifiers.Abstract) != 0)
-				attr |= TypeAttributes.Abstract;
-			if ((modifier & Modifiers.Sealed) != 0)
-				attr |= TypeAttributes.Sealed;
-			if ((modifier & Modifiers.Static) != 0)
-				attr |= TypeAttributes.Abstract | TypeAttributes.Sealed;
-			
-			if ((modifier & Modifiers.Public) != 0)
-				attr |= TypeAttributes.Public;
-			else
-				attr |= TypeAttributes.NotPublic;
-			
-			return attr;
-		}
-		
-		#region ICSharpCode.SharpRefactory.Parser.IAstVisitor interface implementation
-		public override object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
-		{
-			if (compilationUnit == null) {
-				throw new ArgumentNullException("compilationUnit");
-			}
-			CodeNamespace globalNamespace = new CodeNamespace("Global");
-			//namespaces.Add(globalNamespace);
-			namespaceDeclarations.Push(globalNamespace);
-			compilationUnit.AcceptChildren(this, data);
-			codeCompileUnit.Namespaces.Add(globalNamespace);
-			return globalNamespace;
-		}
-		
-		public override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data)
-		{
-			CodeNamespace currentNamespace = new CodeNamespace(namespaceDeclaration.Name);
-			//namespaces.Add(currentNamespace);
-			// add imports from mother namespace
-			foreach (CodeNamespaceImport import in ((CodeNamespace)namespaceDeclarations.Peek()).Imports) {
-				currentNamespace.Imports.Add(import);
-			}
-			namespaceDeclarations.Push(currentNamespace);
-			namespaceDeclaration.AcceptChildren(this, data);
-			namespaceDeclarations.Pop();
-			codeCompileUnit.Namespaces.Add(currentNamespace);
-			
-			// Nested namespaces are not allowed in CodeDOM
-			return null;
-		}
-		
-		public override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
-		{
-			foreach (Using u in usingDeclaration.Usings) {
-				namespaceDeclarations.Peek().Imports.Add(new CodeNamespaceImport(u.Name));
-			}
-			return null;
-		}
-
-		// RG
-		public override object VisitEventDeclaration(EventDeclaration eventDeclaration, object data)
-		{
-			CodeMemberEvent evt = new CodeMemberEvent();
-			evt.Type = ConvType(eventDeclaration.TypeReference);
-			evt.Name = eventDeclaration.Name;
-
-			evt.Attributes = ConvMemberAttributes(eventDeclaration.Modifier);
-
-			typeDeclarations.Peek().Members.Add(evt);
-
-			return null;
-		}
-		
-		public override object VisitAttributeSection(AttributeSection attributeSection, object data)
-		{
-			return null;
-		}
-
-		// RG: CodeTypeReferenceExpression
-		public override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data)
-		{
-			return new CodeTypeReferenceExpression(ConvType(typeReferenceExpression.TypeReference));
-		}
-
-		public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
-		{
-			TypeDeclaration oldTypeDeclaration = currentTypeDeclaration;
-			this.currentTypeDeclaration = typeDeclaration;
-			CodeTypeDeclaration codeTypeDeclaration = new CodeTypeDeclaration(typeDeclaration.Name);
-			codeTypeDeclaration.TypeAttributes = ConvTypeAttributes(typeDeclaration.Modifier);
-			codeTypeDeclaration.IsClass     = typeDeclaration.Type == ClassType.Class;
-			codeTypeDeclaration.IsEnum      = typeDeclaration.Type == ClassType.Enum;
-			codeTypeDeclaration.IsInterface = typeDeclaration.Type == ClassType.Interface;
-			codeTypeDeclaration.IsStruct    = typeDeclaration.Type == ClassType.Struct;
-			codeTypeDeclaration.IsPartial = (typeDeclaration.Modifier & Modifiers.Partial) != 0;
-			
-			if (typeDeclaration.BaseTypes != null) {
-				foreach (TypeReference typeRef in typeDeclaration.BaseTypes) {
-					codeTypeDeclaration.BaseTypes.Add(ConvType(typeRef));
-				}
-			}
-			
-			typeDeclarations.Push(codeTypeDeclaration);
-			typeDeclaration.AcceptChildren(this, data);
-			typeDeclarations.Pop();
-			
-			if (typeDeclarations.Count > 0) {
-				typeDeclarations.Peek().Members.Add(codeTypeDeclaration);
-			} else {
-				namespaceDeclarations.Peek().Types.Add(codeTypeDeclaration);
-			}
-			currentTypeDeclaration = oldTypeDeclaration;
-			
-			return null;
-		}
-		
-		public override object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data)
-		{
-			CodeTypeDelegate codeTypeDelegate = new CodeTypeDelegate(delegateDeclaration.Name);
-			codeTypeDelegate.Attributes = ConvMemberAttributes(delegateDeclaration.Modifier);
-			codeTypeDelegate.ReturnType = ConvType(delegateDeclaration.ReturnType);
-
-			foreach (ParameterDeclarationExpression parameter in delegateDeclaration.Parameters)
-			{
-				codeTypeDelegate.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
-			}
-
-			if (typeDeclarations.Count > 0)
-			{
-				typeDeclarations.Peek().Members.Add(codeTypeDelegate);
-			}
-			else
-			{
-				namespaceDeclarations.Peek().Types.Add(codeTypeDelegate);
-			}
-
-			return null;
-		}
-		
-		public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
-		{
-			return null;
-		}
-		
-		public override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data)
-		{
-			for (int i = 0; i < fieldDeclaration.Fields.Count; ++i) {
-				VariableDeclaration field = (VariableDeclaration)fieldDeclaration.Fields[i];
-				
-				if ((fieldDeclaration.Modifier & Modifiers.WithEvents) != 0) {
-					//this.withEventsFields.Add(field);
-				}
-				TypeReference fieldType = fieldDeclaration.GetTypeForField(i);
-				
-				if (fieldType.IsNull) {
-					fieldType = new TypeReference(typeDeclarations.Peek().Name);
-				}
-				
-				CodeMemberField memberField = new CodeMemberField(ConvType(fieldType), field.Name);
-				memberField.Attributes = ConvMemberAttributes(fieldDeclaration.Modifier);
-				if (!field.Initializer.IsNull) {
-					memberField.InitExpression = (CodeExpression)field.Initializer.AcceptVisitor(this, data);
-				}
-				
-				typeDeclarations.Peek().Members.Add(memberField);
-			}
-			
-			return null;
-		}
-		
-		public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
-		{
-			InitMethodScope();
-
-			CodeMemberMethod memberMethod = new CodeMemberMethod();
-			memberMethod.Name = methodDeclaration.Name;
-			memberMethod.Attributes = ConvMemberAttributes(methodDeclaration.Modifier);
-			memberMethod.ReturnType = ConvType(methodDeclaration.TypeReference);
-
-			// RG: Private Interface Decl
-			if ((memberMethod.Attributes & MemberAttributes.Public) != MemberAttributes.Public &&
-			    methodDeclaration.InterfaceImplementations.Count > 0)
-			{
-				memberMethod.PrivateImplementationType = ConvType(methodDeclaration.InterfaceImplementations[0].InterfaceType);
-			}
-
-			codeStack.Push(memberMethod.Statements);
-			
-			typeDeclarations.Peek().Members.Add(memberMethod);
-			
-			// Add Method Parameters
-			parameters.Clear();
-
-			foreach (ParameterDeclarationExpression parameter in methodDeclaration.Parameters)
-			{
-				memberMethod.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
-			}
-
-			usingId = 0; // RG
-			foreachId = 0;
-			switchId = 0;
-			doId = 0;
-			Breakable.NextId = 0;
-			variables.Clear();
-			methodDeclaration.Body.AcceptChildren(this, data);
-			
-			codeStack.Pop();
-			
-			return null;
-		}
-
-		// RG
-		public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
-		{
-			CodeMemberProperty memberProperty = new CodeMemberProperty();
-			memberProperty.Name = propertyDeclaration.Name;
-			memberProperty.Attributes = ConvMemberAttributes(propertyDeclaration.Modifier);
-			memberProperty.HasGet = propertyDeclaration.HasGetRegion;
-			memberProperty.HasSet = propertyDeclaration.HasSetRegion;
-			memberProperty.Type = ConvType(propertyDeclaration.TypeReference);
-
-			typeDeclarations.Peek().Members.Add(memberProperty);
-
-			// Add Method Parameters
-			foreach (ParameterDeclarationExpression parameter in propertyDeclaration.Parameters)
-			{
-				memberProperty.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
-			}
-
-			if (memberProperty.HasGet)
-			{
-				codeStack.Push(memberProperty.GetStatements);
-				propertyDeclaration.GetRegion.Block.AcceptChildren(this, data);
-				codeStack.Pop();
-			}
-
-			if (memberProperty.HasSet)
-			{
-				codeStack.Push(memberProperty.SetStatements);
-				propertyDeclaration.SetRegion.Block.AcceptChildren(this, data);
-				codeStack.Pop();
-			}
-
-			return null;
-		}
-		
-		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
-		{
-			InitMethodScope();
-
-			CodeConstructor memberMethod = new CodeConstructor();
-			memberMethod.Attributes = ConvMemberAttributes(constructorDeclaration.Modifier);
-
-			typeDeclarations.Peek().Members.Add(memberMethod);
-
-			codeStack.Push(NullStmtCollection);
-			foreach (ParameterDeclarationExpression parameter in constructorDeclaration.Parameters)
-			{
-				memberMethod.Parameters.Add((CodeParameterDeclarationExpression)VisitParameterDeclarationExpression(parameter, data));
-			}
-			
-			if (constructorDeclaration.ConstructorInitializer != null)
-			{
-				if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.Base)
-				{
-					if (constructorDeclaration.ConstructorInitializer.Arguments.Count == 0)
-					{
-						memberMethod.BaseConstructorArgs.Add(new CodeSnippetExpression());
-					}
-					
-					foreach (Expression o in constructorDeclaration.ConstructorInitializer.Arguments)
-					{
-						memberMethod.BaseConstructorArgs.Add((CodeExpression)o.AcceptVisitor(this, data));
-					}
-				}
-
-				if (constructorDeclaration.ConstructorInitializer.ConstructorInitializerType == ConstructorInitializerType.This)
-				{
-					if (constructorDeclaration.ConstructorInitializer.Arguments.Count == 0)
-					{
-						memberMethod.ChainedConstructorArgs.Add(new CodeSnippetExpression());
-					}
-
-					foreach (Expression o in constructorDeclaration.ConstructorInitializer.Arguments)
-					{
-						memberMethod.ChainedConstructorArgs.Add((CodeExpression)o.AcceptVisitor(this, data));
-					}
-				}
-			}
-			codeStack.Pop();
-
-			codeStack.Push(memberMethod.Statements);
-			constructorDeclaration.Body.AcceptChildren(this, data);
-			codeStack.Pop();
-			
-			return null;
-		}
-
-		public override object VisitBlockStatement(BlockStatement blockStatement, object data)
-		{
-			blockStatement.AcceptChildren(this, data);
-			return null;
-		}
-		
-		public override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data)
-		{
-			object exp = expressionStatement.Expression.AcceptVisitor(this, data);
-			if (exp is CodeExpression) {
-				AddStmt(new CodeExpressionStatement((CodeExpression)exp));
-			}
-			return exp;
-		}
-		
-		public override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
-		{
-			CodeVariableDeclarationStatement declStmt = null;
-			
-			for (int i = 0; i < localVariableDeclaration.Variables.Count; ++i) {
-				CodeTypeReference type = ConvType(localVariableDeclaration.GetTypeForVariable(i) ?? new TypeReference("System.Object", true));
-				VariableDeclaration var = (VariableDeclaration)localVariableDeclaration.Variables[i];
-				if (!var.Initializer.IsNull) {
-					declStmt = new CodeVariableDeclarationStatement(type,
-					                                                var.Name,
-					                                                (CodeExpression)((INode)var.Initializer).AcceptVisitor(this, data));
-				} else {
-					declStmt = new CodeVariableDeclarationStatement(type,
-					                                                var.Name);
-				}
-				variables.Add(declStmt);
-				AddStmt(declStmt);
-			}
-			
-			return declStmt;
-		}
-		
-		public override object VisitReturnStatement(ReturnStatement returnStatement, object data)
-		{
-			CodeMethodReturnStatement returnStmt;
-			if (returnStatement.Expression.IsNull)
-				returnStmt = new CodeMethodReturnStatement();
-			else
-				returnStmt = new CodeMethodReturnStatement((CodeExpression)returnStatement.Expression.AcceptVisitor(this,data));
-			
-			AddStmt(returnStmt);
-			
-			return returnStmt;
-		}
-		
-		public override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data)
-		{
-			CodeConditionStatement ifStmt = new CodeConditionStatement();
-			
-			ifStmt.Condition = (CodeExpression)ifElseStatement.Condition.AcceptVisitor(this, data);
-			
-			codeStack.Push(ifStmt.TrueStatements);
-			foreach (Statement stmt in ifElseStatement.TrueStatement) {
-				if (stmt is BlockStatement) {
-					stmt.AcceptChildren(this, data);
-				} else {
-					stmt.AcceptVisitor(this, data);
-				}
-			}
-			codeStack.Pop();
-			
-			codeStack.Push(ifStmt.FalseStatements);
-			foreach (Statement stmt in ifElseStatement.FalseStatement) {
-				if (stmt is BlockStatement) {
-					stmt.AcceptChildren(this, data);
-				} else {
-					stmt.AcceptVisitor(this, data);
-				}
-			}
-			codeStack.Pop();
-			
-			AddStmt(ifStmt);
-			
-			return ifStmt;
-		}
-
-		int foreachId = 0; // in case of nested foreach statments
-
-		public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
-		{
-			// RG:
-			//  foreach (T t in x)
-			//  {
-			//      stmts;
-			//  }
-			//
-			// Emulate with
-			//
-			//  for (System.Collections.IEnumerator _it = x.GetEnumerator(); _it.MoveNext(); )
-			//  {
-			//      T t = ((T)_it.Current);
-			//
-			//      stmts;
-			//  }
-
-			foreachId++;
-			string name = "_it" + foreachId.ToString();
-
-			CodeIterationStatement _for1 = new CodeIterationStatement();
-			breakableStack.Push(new Breakable());
-
-			// init
-			CodeVariableDeclarationStatement _decl2 = new CodeVariableDeclarationStatement();
-			CodeMethodInvokeExpression _invoke1 = new CodeMethodInvokeExpression();
-			CodeMethodReferenceExpression _GetEnumerator_method1 = new CodeMethodReferenceExpression();
-			_GetEnumerator_method1.MethodName = "GetEnumerator";
-			
-			//CodeCastExpression _cast1 = new CodeCastExpression();
-			//codeStack.Push(NullStmtCollection);
-			//_cast1.Expression = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
-			//codeStack.Pop();
-			//CodeTypeReference _IEnumerable_type1 = new CodeTypeReference("System.Collections.IEnumerable");
-			//_cast1.TargetType = _IEnumerable_type1;
-
-			//_GetEnumerator_method1.TargetObject = _cast1;
-
-			codeStack.Push(NullStmtCollection);
-			_GetEnumerator_method1.TargetObject = (CodeExpression)foreachStatement.Expression.AcceptVisitor(this, data);
-			codeStack.Pop();
-
-			_invoke1.Method = _GetEnumerator_method1;
-			_decl2.InitExpression = _invoke1;
-			_decl2.Name = name;
-			CodeTypeReference _IEnumerator_type1 = new CodeTypeReference("System.Collections.IEnumerator");
-			_decl2.Type = _IEnumerator_type1;
-			_for1.InitStatement = _decl2;
-
-			// Condition
-			CodeMethodInvokeExpression _invoke2 = new CodeMethodInvokeExpression();
-			CodeMethodReferenceExpression _MoveNext_method1 = new CodeMethodReferenceExpression();
-			_MoveNext_method1.MethodName = "MoveNext";
-			CodeVariableReferenceExpression _arg2 = new CodeVariableReferenceExpression();
-			_arg2.VariableName = name;
-			_MoveNext_method1.TargetObject = _arg2;
-			_invoke2.Method = _MoveNext_method1;
-			_for1.TestExpression = _invoke2;
-
-			// Empty Increment
-			_for1.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());
-
-			// T t = ((T)_it.Current);
-			CodeVariableDeclarationStatement _decl3 = new CodeVariableDeclarationStatement();
-			CodeCastExpression _cast2 = new CodeCastExpression();
-			CodePropertyReferenceExpression _prop1 = new CodePropertyReferenceExpression();
-			_prop1.PropertyName = "Current";
-			CodeVariableReferenceExpression _arg3 = new CodeVariableReferenceExpression();
-			_arg3.VariableName = name;
-			_prop1.TargetObject = _arg3;
-			_cast2.Expression = _prop1;
-			CodeTypeReference _System_String_type5 = ConvType(foreachStatement.TypeReference);
-			_cast2.TargetType = _System_String_type5;
-			_decl3.InitExpression = _cast2;
-			_decl3.Name = foreachStatement.VariableName;
-			CodeTypeReference _System_String_type6 = ConvType(foreachStatement.TypeReference);
-			_decl3.Type = _System_String_type6;
-			_for1.Statements.Add(_decl3);
-			_for1.Statements.Add(new CodeSnippetStatement());
-
-			codeStack.Push(_for1.Statements);
-			foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			codeStack.Pop();
-
-			Breakable breakable = breakableStack.Pop();
-
-			if (breakable.IsContinue)
-			{
-				_for1.Statements.Add(new CodeSnippetStatement());
-				_for1.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
-			}
-
-			AddStmt(_for1);
-
-			if (breakable.IsBreak)
-			{
-				AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
-			}
-
-			return _for1;
-		}
-
-		int doId = 0;
-
-		// RG:
-		public override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data)
-		{
-			CodeIterationStatement forLoop = new CodeIterationStatement();
-			breakableStack.Push(new Breakable());
-
-			codeStack.Push(NullStmtCollection);
-
-			if (doLoopStatement.ConditionPosition == ConditionPosition.End)
-			{
-				// do { } while (expr);
-				//
-				// emulate with:
-				//  for (bool _do = true; _do; _do = expr) {}
-				//
-				doId++;
-				string name = "_do" + doId;
-
-				forLoop.InitStatement = new CodeVariableDeclarationStatement(typeof(System.Boolean), name, new CodePrimitiveExpression(true));
-				forLoop.TestExpression = new CodeVariableReferenceExpression(name);
-
-				forLoop.IncrementStatement = new CodeAssignStatement(new CodeVariableReferenceExpression(name),
-				                                                     doLoopStatement.Condition == null ? new CodePrimitiveExpression(true) : (CodeExpression)doLoopStatement.Condition.AcceptVisitor(this, data));
-			}
-			else
-			{
-				// while (expr) {}
-				//
-				// emulate with:
-				//  for (; expr;) {}
-				//
-
-				// Empty Init and Increment Statements
-				forLoop.InitStatement = new CodeExpressionStatement(new CodeSnippetExpression());
-				forLoop.IncrementStatement = new CodeExpressionStatement(new CodeSnippetExpression());
-
-				if (doLoopStatement.Condition == null)
-				{
-					forLoop.TestExpression = new CodePrimitiveExpression(true);
-				}
-				else
-				{
-					forLoop.TestExpression = (CodeExpression)doLoopStatement.Condition.AcceptVisitor(this, data);
-				}
-			}
-
-			codeStack.Pop();
-
-			codeStack.Push(forLoop.Statements);
-			doLoopStatement.EmbeddedStatement.AcceptVisitor(this, data);
-			codeStack.Pop();
-
-			if (forLoop.Statements.Count == 0)
-			{
-				forLoop.Statements.Add(new CodeSnippetStatement());
-			}
-
-			Breakable breakable = breakableStack.Pop();
-
-			if (breakable.IsContinue)
-			{
-				forLoop.Statements.Add(new CodeSnippetStatement());
-				forLoop.Statements.Add(new CodeLabeledStatement("continue" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
-			}
-
-			AddStmt(forLoop);
-
-			if (breakable.IsBreak)
-			{
-				AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
-			}
-
-			return forLoop;
-		}
-		
-		public override object VisitLabelStatement(LabelStatement labelStatement, object data)
-		{
-			System.CodeDom.CodeLabeledStatement labelStmt = new CodeLabeledStatement(labelStatement.Label);
-			
-			// Add Statement to Current Statement Collection
-			AddStmt(labelStmt);
-			
-			return labelStmt;
-		}
-		
-		public override object VisitGotoStatement(GotoStatement gotoStatement, object data)
-		{
-			System.CodeDom.CodeGotoStatement gotoStmt = new CodeGotoStatement(gotoStatement.Label);
-			
-			// Add Statement to Current Statement Collection
-			AddStmt(gotoStmt);
-			
-			return gotoStmt;
-		}
-
-		// RG
-		int switchId = 0;
-
-		public override object VisitSwitchStatement(SwitchStatement switchStatement, object data)
-		{
-			// switch(arg) { case label1: expr1; case label2: expr2; default: expr3; }
-			//
-			// Emulate With:
-			// 
-			//  object _switch1 = arg;
-			//  if (arg.Equals(label1))
-			//  {
-			//      expr1;
-			//  }
-			//  else
-			//  {
-			//      if (arg.Equals(label2))
-			//      {
-			//          expr2;
-			//      }
-			//      else
-			//      {
-			//          expr3;
-			//      }
-			//  }
-			//
-
-			switchId++; // in case nested switch() statements
-			string name = "_switch" + switchId.ToString();
-
-			breakableStack.Push(new Breakable(false));
-
-			bool isSwitchArg = false;
-
-			CodeVariableReferenceExpression switchArg = null;
-			SwitchSection defaultSection = null;
-
-			// get default section
-			foreach (SwitchSection section in switchStatement.SwitchSections)
-			{
-				foreach (CaseLabel label in section.SwitchLabels)
-				{
-					if (label.IsDefault)
-					{
-						defaultSection = section;
-						break;
-					}
-				}
-
-				if (defaultSection != null)
-					break;
-			}
-
-
-			CodeConditionStatement _if = null;
-
-			// get default section
-			foreach (SwitchSection section in switchStatement.SwitchSections)
-			{
-				if (section != defaultSection)
-				{
-					if (!isSwitchArg)
-					{
-						isSwitchArg = true;
-
-						codeStack.Push(NullStmtCollection);
-						CodeVariableDeclarationStatement switchStmt = new CodeVariableDeclarationStatement("System.Object", name, (CodeExpression)switchStatement.SwitchExpression.AcceptVisitor(this, data));
-						codeStack.Pop();
-
-						switchArg = new CodeVariableReferenceExpression(name);
-
-						AddStmt(switchStmt);
-						AddStmt(new CodeSnippetStatement());
-					}
-
-					codeStack.Push(NullStmtCollection);
-
-					CodeExpression condition = null;
-					foreach (CaseLabel label in section.SwitchLabels)
-					{
-						CodeMethodInvokeExpression cond = new CodeMethodInvokeExpression(switchArg, "Equals", (CodeExpression)label.Label.AcceptVisitor(this, data));
-						if (condition == null)
-						{
-							condition = cond;
-						}
-						else
-						{
-							condition = new CodeBinaryOperatorExpression(condition, CodeBinaryOperatorType.BooleanOr, cond);
-						}
-					}
-
-					codeStack.Pop();
-
-					if (_if == null)
-					{
-						_if = new CodeConditionStatement();
-						_if.Condition = condition;
-
-						AddStmt(_if);
-					}
-					else
-					{
-						CodeConditionStatement _if2 = new CodeConditionStatement();
-						_if2.Condition = condition;
-
-						_if.FalseStatements.Add(_if2);
-
-						_if = _if2;
-					}
-
-					codeStack.Push(_if.TrueStatements);
-
-					for (int i = 0; i < section.Children.Count; i++)
-					{
-						INode stmt = section.Children[i];
-
-//						if (i == section.Children.Count - 1 && stmt is BreakStatement)
-//							break;
-
-						stmt.AcceptVisitor(this, data);
-					}
-
-					codeStack.Pop();
-				}
-			}
-
-			if (defaultSection != null)
-			{
-				if (_if != null)
-					codeStack.Push(_if.FalseStatements);
-
-				for (int i = 0; i < defaultSection.Children.Count; i++)
-				{
-					INode stmt = defaultSection.Children[i];
-
-//					if (i == defaultSection.Children.Count - 1 && stmt is BreakStatement)
-//						break;
-
-					stmt.AcceptVisitor(this, data);
-				}
-
-				if (_if != null)
-					codeStack.Pop();
-			}
-
-			Breakable breakable = breakableStack.Pop();
-
-			if (breakable.IsContinue)
-			{
-				throw new Exception("Continue Inside Switch Not Supported");
-			}
-
-			if (breakable.IsBreak)
-			{
-				AddStmt(new CodeLabeledStatement("break" + breakable.Id, new CodeExpressionStatement(new CodeSnippetExpression())));
-			}
-
-			return null;
-		}
-		
-		public override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
-		{
-			// add a try-catch-finally
-			CodeTryCatchFinallyStatement tryStmt = new CodeTryCatchFinallyStatement();
-			
-			codeStack.Push(tryStmt.TryStatements);
-			
-			tryCatchStatement.StatementBlock.AcceptChildren(this, data);
-			codeStack.Pop();
-			
-			if (!tryCatchStatement.FinallyBlock.IsNull) {
-				codeStack.Push(tryStmt.FinallyStatements);
-				
-				tryCatchStatement.FinallyBlock.AcceptChildren(this,data);
-				codeStack.Pop();
-			}
-			
-			foreach (CatchClause clause in tryCatchStatement.CatchClauses)
-			{
-				CodeCatchClause catchClause = new CodeCatchClause(clause.VariableName);
-				catchClause.CatchExceptionType = ConvType(clause.TypeReference);
-				tryStmt.CatchClauses.Add(catchClause);
-				
-				codeStack.Push(catchClause.Statements);
-				
-				clause.StatementBlock.AcceptChildren(this, data);
-				codeStack.Pop();
-			}
-			
-			// Add Statement to Current Statement Collection
-			AddStmt(tryStmt);
-			
-			return tryStmt;
-		}
-		
-		public override object VisitThrowStatement(ThrowStatement throwStatement, object data)
-		{
-			CodeThrowExceptionStatement throwStmt = new CodeThrowExceptionStatement((CodeExpression)throwStatement.Expression.AcceptVisitor(this, data));
-			
-			// Add Statement to Current Statement Collection
-			AddStmt(throwStmt);
-			
-			return throwStmt;
-		}
-		
-		#region Expressions
-		public override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
-		{
-			return new CodePrimitiveExpression(primitiveExpression.Value);
-		}
-		
-		public override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
-		{
-			CodeBinaryOperatorType op = CodeBinaryOperatorType.Add;
-			switch (binaryOperatorExpression.Op) {
-				case BinaryOperatorType.Add:
-					op = CodeBinaryOperatorType.Add;
-					break;
-				case BinaryOperatorType.BitwiseAnd:
-					op = CodeBinaryOperatorType.BitwiseAnd;
-					break;
-				case BinaryOperatorType.BitwiseOr:
-					op = CodeBinaryOperatorType.BitwiseOr;
-					break;
-				case BinaryOperatorType.LogicalAnd:
-					op = CodeBinaryOperatorType.BooleanAnd;
-					break;
-				case BinaryOperatorType.LogicalOr:
-					op = CodeBinaryOperatorType.BooleanOr;
-					break;
-				case BinaryOperatorType.Divide:
-				case BinaryOperatorType.DivideInteger:
-					op = CodeBinaryOperatorType.Divide;
-					break;
-				case BinaryOperatorType.GreaterThan:
-					op = CodeBinaryOperatorType.GreaterThan;
-					break;
-				case BinaryOperatorType.GreaterThanOrEqual:
-					op = CodeBinaryOperatorType.GreaterThanOrEqual;
-					break;
-				case BinaryOperatorType.Equality:
-				case BinaryOperatorType.InEquality:
-					op = CodeBinaryOperatorType.ValueEquality;
-					break;
-				case BinaryOperatorType.LessThan:
-					op = CodeBinaryOperatorType.LessThan;
-					break;
-				case BinaryOperatorType.LessThanOrEqual:
-					op = CodeBinaryOperatorType.LessThanOrEqual;
-					break;
-				case BinaryOperatorType.Modulus:
-					op = CodeBinaryOperatorType.Modulus;
-					break;
-				case BinaryOperatorType.Multiply:
-					op = CodeBinaryOperatorType.Multiply;
-					break;
-				case BinaryOperatorType.Subtract:
-					op = CodeBinaryOperatorType.Subtract;
-					break;
-				case BinaryOperatorType.ShiftLeft:
-				case BinaryOperatorType.ShiftRight:
-					// CodeDOM suxx
-					op = CodeBinaryOperatorType.Multiply;
-					break;
-				case BinaryOperatorType.ReferenceEquality:
-					op = CodeBinaryOperatorType.IdentityEquality;
-					break;
-				case BinaryOperatorType.ReferenceInequality:
-					op = CodeBinaryOperatorType.IdentityInequality;
-					break;
-					
-				case BinaryOperatorType.ExclusiveOr:
-					// CodeDom doesn't support ExclusiveOr
-					op = CodeBinaryOperatorType.BitwiseAnd;
-					break;
-			}
-
-			System.Diagnostics.Debug.Assert(!binaryOperatorExpression.Left.IsNull);
-			System.Diagnostics.Debug.Assert(!binaryOperatorExpression.Right.IsNull);
-
-			var cboe = new CodeBinaryOperatorExpression(
-				(CodeExpression)binaryOperatorExpression.Left.AcceptVisitor(this, data),
-				op,
-				(CodeExpression)binaryOperatorExpression.Right.AcceptVisitor(this, data));
-			if (binaryOperatorExpression.Op == BinaryOperatorType.InEquality) {
-				cboe = new CodeBinaryOperatorExpression(cboe, CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
-			}
-			return cboe;
-		}
-		
-		public override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
-		{
-			return parenthesizedExpression.Expression.AcceptVisitor(this, data);
-		}
-		
-		public override object VisitInvocationExpression(InvocationExpression invocationExpression, object data)
-		{
-			Expression     target     = invocationExpression.TargetObject;
-			CodeExpression targetExpr;
-			string         methodName = null;
-			if (target == null) {
-				targetExpr = new CodeThisReferenceExpression();
-			} else if (target is MemberReferenceExpression) {
-				MemberReferenceExpression fRef = (MemberReferenceExpression)target;
-				targetExpr = null;
-				if (fRef.TargetObject is MemberReferenceExpression) {
-					if (IsPossibleTypeReference((MemberReferenceExpression)fRef.TargetObject)) {
-						targetExpr = ConvertToTypeReference((MemberReferenceExpression)fRef.TargetObject);
-					}
-				}
-				if (targetExpr == null)
-					targetExpr = (CodeExpression)fRef.TargetObject.AcceptVisitor(this, data);
-				
-				methodName = fRef.MemberName;
-				// HACK for : Microsoft.VisualBasic.ChrW(NUMBER)
-				if (methodName == "ChrW") {
-					return new CodeCastExpression("System.Char", GetExpressionList(invocationExpression.Arguments)[0]);
-				}
-			} else if (target is IdentifierExpression) {
-				targetExpr = new CodeThisReferenceExpression();
-				methodName = ((IdentifierExpression)target).Identifier;
-			} else {
-				targetExpr = (CodeExpression)target.AcceptVisitor(this, data);
-			}
-			return new CodeMethodInvokeExpression(targetExpr, methodName, GetExpressionList(invocationExpression.Arguments));
-		}
-		
-		public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
-		{
-			if (!IsLocalVariable(identifierExpression.Identifier) && IsField(identifierExpression.Identifier)) {
-				return new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), identifierExpression.Identifier);
-			}
-			return new CodeVariableReferenceExpression(identifierExpression.Identifier);
-		}
-		
-		public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
-		{
-			CodeExpression var;
-			CodeAssignStatement assign;
-
-			switch (unaryOperatorExpression.Op) {
-				case UnaryOperatorType.Minus:
-					if (unaryOperatorExpression.Expression is PrimitiveExpression) {
-						PrimitiveExpression expression = (PrimitiveExpression)unaryOperatorExpression.Expression;
-						if (expression.Value is int) {
-							return new CodePrimitiveExpression(- (int)expression.Value);
-						}
-						if (expression.Value is System.UInt32 || expression.Value is System.UInt16) {
-							return new CodePrimitiveExpression(Int32.Parse("-" + expression.StringValue));
-						}
-						
-						if (expression.Value is long) {
-							return new CodePrimitiveExpression(- (long)expression.Value);
-						}
-						if (expression.Value is double) {
-							return new CodePrimitiveExpression(- (double)expression.Value);
-						}
-						if (expression.Value is float) {
-							return new CodePrimitiveExpression(- (float)expression.Value);
-						}
-						
-					}
-					return  new CodeBinaryOperatorExpression(new CodePrimitiveExpression(0),
-					                                         CodeBinaryOperatorType.Subtract,
-					                                         (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data));
-				case UnaryOperatorType.Plus:
-					return unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-					
-				case UnaryOperatorType.PostIncrement:
-					// emulate i++, with i = i + 1
-					var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-
-					assign = new CodeAssignStatement(var,
-					                                 new CodeBinaryOperatorExpression(var,
-					                                                                  CodeBinaryOperatorType.Add,
-					                                                                  new CodePrimitiveExpression(1)));
-
-					AddStmt(assign);
-
-					return assign;
-
-					//return new CodeAssignStatement(var,
-					//               new CodeBinaryOperatorExpression(var,
-					//                                                CodeBinaryOperatorType.Add,
-					//                                                new CodePrimitiveExpression(1)));
-
-					// RG: needs to return an Expression - Not a Statement
-					//return new CodeBinaryOperatorExpression(var,
-					//                               CodeBinaryOperatorType.Assign,
-					//                               new CodeBinaryOperatorExpression(var,
-					//                                                                CodeBinaryOperatorType.Add,
-					//                                                                new CodePrimitiveExpression(1)));
-					
-				case UnaryOperatorType.PostDecrement:
-					// emulate i--, with i = i - 1
-					var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-
-					assign = new CodeAssignStatement(var,
-					                                 new CodeBinaryOperatorExpression(var,
-					                                                                  CodeBinaryOperatorType.Subtract,
-					                                                                  new CodePrimitiveExpression(1)));
-
-					AddStmt(assign);
-
-					return assign;
-					
-					//return new CodeAssignStatement(var,
-					//                               new CodeBinaryOperatorExpression(var,
-					//                                                                CodeBinaryOperatorType.Subtract,
-					//                                                                new CodePrimitiveExpression(1)));
-
-					// RG: needs to return an Expression - Not a Statement
-					//return new CodeBinaryOperatorExpression(var,
-					//               CodeBinaryOperatorType.Assign,
-					//               new CodeBinaryOperatorExpression(var,
-					//                                                CodeBinaryOperatorType.Subtract,
-					//                                                new CodePrimitiveExpression(1)));
-					
-				case UnaryOperatorType.Decrement:
-					// emulate --i, with i = i - 1
-					var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-
-					assign = new CodeAssignStatement(var,
-					                                 new CodeBinaryOperatorExpression(var,
-					                                                                  CodeBinaryOperatorType.Subtract,
-					                                                                  new CodePrimitiveExpression(1)));
-					AddStmt(assign);
-
-					return assign;
-					//return new CodeAssignStatement(var,
-					//                               new CodeBinaryOperatorExpression(var,
-					//                                                                CodeBinaryOperatorType.Subtract,
-					//                                                                new CodePrimitiveExpression(1)));
-
-					//return new CodeBinaryOperatorExpression(var,
-					//                CodeBinaryOperatorType.Assign,
-					//               new CodeBinaryOperatorExpression(var,
-					//                                                CodeBinaryOperatorType.Subtract,
-					//                                                new CodePrimitiveExpression(1)));
-					
-				case UnaryOperatorType.Increment:
-					// emulate ++i, with i = i + 1
-					var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-
-					assign = new CodeAssignStatement(var,
-					                                 new CodeBinaryOperatorExpression(var,
-					                                                                  CodeBinaryOperatorType.Add,
-					                                                                  new CodePrimitiveExpression(1)));
-
-					AddStmt(assign);
-
-					return assign;
-
-					//return new CodeAssignStatement(var,
-					//                               new CodeBinaryOperatorExpression(var,
-					//                                                                CodeBinaryOperatorType.Add,
-					//                                                                new CodePrimitiveExpression(1)));
-
-					//return new CodeBinaryOperatorExpression(var,
-					//                CodeBinaryOperatorType.Assign,
-					//                new CodeBinaryOperatorExpression(var,
-					//                                                CodeBinaryOperatorType.Add,
-					//                                                new CodePrimitiveExpression(1)));
-
-					// RG:
-				case UnaryOperatorType.Not:
-					// emulate !a with a == false
-					var = (CodeExpression)unaryOperatorExpression.Expression.AcceptVisitor(this, data);
-					
-					CodeBinaryOperatorExpression cboe = var as CodeBinaryOperatorExpression;
-					if (cboe != null && cboe.Operator == CodeBinaryOperatorType.IdentityEquality) {
-						return new CodeBinaryOperatorExpression(cboe.Left, CodeBinaryOperatorType.IdentityInequality, cboe.Right);
-					} else {
-						return new CodeBinaryOperatorExpression(var,CodeBinaryOperatorType.ValueEquality, new CodePrimitiveExpression(false));
-					}
-
-				default:
-					throw new NotSupportedException("CodeDom does not support Unary Operators");
-			}
-		}
-
-		bool methodReference = false;
-		
-		void AddEventHandler(Expression eventExpr, Expression handler, object data)
-		{
-			methodReference = true;
-			CodeExpression methodInvoker = (CodeExpression)handler.AcceptVisitor(this, data);
-			methodReference = false;
-			if (!(methodInvoker is CodeObjectCreateExpression)) {
-				// we need to create an event handler here
-				methodInvoker = new CodeObjectCreateExpression(new CodeTypeReference("System.EventHandler"), methodInvoker);
-			}
-			
-			if (eventExpr is IdentifierExpression) {
-				AddStmt(new CodeAttachEventStatement(new CodeEventReferenceExpression(new CodeThisReferenceExpression(), ((IdentifierExpression)eventExpr).Identifier),
-				                                     methodInvoker));
-			} else {
-				MemberReferenceExpression fr = (MemberReferenceExpression)eventExpr;
-				AddStmt(new CodeAttachEventStatement(new CodeEventReferenceExpression((CodeExpression)fr.TargetObject.AcceptVisitor(this, data), fr.MemberName),
-				                                     methodInvoker));
-			}
-		}
-		
-		public override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data)
-		{
-			if (assignmentExpression.Op == AssignmentOperatorType.Add) {
-				AddEventHandler(assignmentExpression.Left, assignmentExpression.Right, data);
-			} else {
-				if (assignmentExpression.Left is IdentifierExpression) {
-					AddStmt(new CodeAssignStatement((CodeExpression)assignmentExpression.Left.AcceptVisitor(this, null), (CodeExpression)assignmentExpression.Right.AcceptVisitor(this, null)));
-				} else {
-					AddStmt(new CodeAssignStatement((CodeExpression)assignmentExpression.Left.AcceptVisitor(this, null), (CodeExpression)assignmentExpression.Right.AcceptVisitor(this, null)));
-				}
-			}
-			return null;
-		}
-		
-		public override object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data)
-		{
-			AddEventHandler(addHandlerStatement.EventExpression, addHandlerStatement.HandlerExpression, data);
-			return null;
-		}
-		
-		public override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data)
-		{
-			return addressOfExpression.Expression.AcceptVisitor(this, data);
-		}
-
-		public override object VisitUsing(Using @using, object data)
-		{
-			return base.VisitUsing(@using, data);
-		}
-
-		// RG
-		int usingId = 0;
-
-		public override object VisitUsingStatement(UsingStatement usingStatement, object data)
-		{
-			// using (new expr) { stmts; }
-			//
-			// emulate with
-			//      object _dispose;
-			//      try
-			//      {
-			//          _dispose = new expr;
-			//
-			//          stmts;
-			//      }
-			//      finally
-			//      {
-			//          if (((_dispose != null)
-			//              && (typeof(System.IDisposable).IsInstanceOfType(_dispose) == true)))
-			//          {
-			//              ((System.IDisposable)(_dispose)).Dispose();
-			//          }
-			//      }
-			//
-
-			usingId++; // in case nested using() statements
-			string name = "_dispose" + usingId.ToString();
-
-			CodeVariableDeclarationStatement disposable = new CodeVariableDeclarationStatement("System.Object", name, new CodePrimitiveExpression(null));
-
-			AddStmt(disposable);
-
-			CodeTryCatchFinallyStatement tryStmt = new CodeTryCatchFinallyStatement();
-
-			CodeVariableReferenceExpression left1 = new CodeVariableReferenceExpression(name);
-
-			codeStack.Push(NullStmtCollection); // send statements to nul Statement collection
-			CodeExpression right1 = (CodeExpression)usingStatement.ResourceAcquisition.AcceptVisitor(this, data);
-			codeStack.Pop();
-
-			CodeAssignStatement assign1 = new CodeAssignStatement(left1, right1);
-
-			tryStmt.TryStatements.Add(assign1);
-			tryStmt.TryStatements.Add(new CodeSnippetStatement());
-
-			codeStack.Push(tryStmt.TryStatements);
-			usingStatement.EmbeddedStatement.AcceptChildren(this, data);
-			codeStack.Pop();
-
-			CodeMethodInvokeExpression isInstanceOfType = new CodeMethodInvokeExpression(new CodeTypeOfExpression(typeof(IDisposable)), "IsInstanceOfType", new CodeExpression[] { left1 });
-
-			CodeConditionStatement if1 = new CodeConditionStatement();
-			if1.Condition = new CodeBinaryOperatorExpression(new CodeBinaryOperatorExpression(left1, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression(null)),
-			                                                 CodeBinaryOperatorType.BooleanAnd,
-			                                                 new CodeBinaryOperatorExpression(isInstanceOfType, CodeBinaryOperatorType.IdentityEquality, new CodePrimitiveExpression(true)));
-			if1.TrueStatements.Add(new CodeMethodInvokeExpression(new CodeCastExpression(typeof(IDisposable),left1), "Dispose", new CodeExpression[] { }));
-
-			tryStmt.FinallyStatements.Add(if1);
-
-			// Add Statement to Current Statement Collection
-			AddStmt(tryStmt);
-
-			return null;
-		}
-		
-		public override object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)
-		{
-			return new CodeTypeOfExpression(ConvType(typeOfExpression.TypeReference));
-		}
-
-		public override object VisitCastExpression(CastExpression castExpression, object data)
-		{
-			CodeTypeReference typeRef = ConvType(castExpression.CastTo);
-			return new CodeCastExpression(typeRef, (CodeExpression)castExpression.Expression.AcceptVisitor(this, data));
-		}
-		
-		public override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data)
-		{
-			return new CodeThisReferenceExpression();
-		}
-		
-		public override object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data)
-		{
-			return new CodeBaseReferenceExpression();
-		}
-		
-		public override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data)
-		{
-			if (arrayCreateExpression.ArrayInitializer.IsNull) {
-				return new CodeArrayCreateExpression(ConvType(arrayCreateExpression.CreateType),
-				                                     arrayCreateExpression.Arguments[0].AcceptVisitor(this, data) as CodeExpression);
-			}
-			return new CodeArrayCreateExpression(ConvType(arrayCreateExpression.CreateType),
-			                                     GetExpressionList(arrayCreateExpression.ArrayInitializer.CreateExpressions));
-		}
-		
-		public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
-		{
-			return new CodeObjectCreateExpression(ConvType(objectCreateExpression.CreateType),
-			                                      objectCreateExpression.Parameters == null ? null : GetExpressionList(objectCreateExpression.Parameters));
-		}
-		
-		public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)
-		{
-			CodeParameterDeclarationExpression parameter = new CodeParameterDeclarationExpression(ConvType(parameterDeclarationExpression.TypeReference), parameterDeclarationExpression.ParameterName);
-
-			parameters.Add(parameter);
-
-			return parameter;
-		}
-
-		bool IsField(string reflectionTypeName, string fieldName)
-		{
-			return environmentInformationProvider.HasField(reflectionTypeName, 0, fieldName);
-		}
-		
-		bool IsFieldReferenceExpression(MemberReferenceExpression fieldReferenceExpression)
-		{
-			if (fieldReferenceExpression.TargetObject is ThisReferenceExpression
-			    || fieldReferenceExpression.TargetObject is BaseReferenceExpression)
-			{
-				//field detection for fields\props inherited from base classes
-				return IsField(fieldReferenceExpression.MemberName);
-			}
-			return false;
-		}
-		
-		public override object VisitMemberReferenceExpression(MemberReferenceExpression fieldReferenceExpression, object data)
-		{
-			if (methodReference) {
-				methodReference = false;
-				return new CodeMethodReferenceExpression((CodeExpression)fieldReferenceExpression.TargetObject.AcceptVisitor(this, data), fieldReferenceExpression.MemberName);
-			}
-			if (IsFieldReferenceExpression(fieldReferenceExpression)) {
-				return new CodeFieldReferenceExpression((CodeExpression)fieldReferenceExpression.TargetObject.AcceptVisitor(this, data),
-				                                        fieldReferenceExpression.MemberName);
-			} else {
-				if (fieldReferenceExpression.TargetObject is MemberReferenceExpression) {
-					if (IsPossibleTypeReference((MemberReferenceExpression)fieldReferenceExpression.TargetObject)) {
-						CodeTypeReferenceExpression typeRef = ConvertToTypeReference((MemberReferenceExpression)fieldReferenceExpression.TargetObject);
-						if (IsField(typeRef.Type.BaseType, fieldReferenceExpression.MemberName)) {
-							return new CodeFieldReferenceExpression(typeRef,
-							                                        fieldReferenceExpression.MemberName);
-						} else {
-							return new CodePropertyReferenceExpression(typeRef,
-							                                           fieldReferenceExpression.MemberName);
-						}
-					}
-				}
-				
-				CodeExpression codeExpression = (CodeExpression)fieldReferenceExpression.TargetObject.AcceptVisitor(this, data);
-				return new CodePropertyReferenceExpression(codeExpression,
-				                                           fieldReferenceExpression.MemberName);
-			}
-		}
-
-		#endregion
-		
-		#endregion
-		bool IsPossibleTypeReference(MemberReferenceExpression fieldReferenceExpression)
-		{
-			while (fieldReferenceExpression.TargetObject is MemberReferenceExpression) {
-				fieldReferenceExpression = (MemberReferenceExpression)fieldReferenceExpression.TargetObject;
-			}
-			IdentifierExpression identifier = fieldReferenceExpression.TargetObject as IdentifierExpression;
-			if (identifier != null)
-				return !IsField(identifier.Identifier) && !IsLocalVariable(identifier.Identifier);
-			TypeReferenceExpression tre = fieldReferenceExpression.TargetObject as TypeReferenceExpression;
-			if (tre != null)
-				return true;
-			return false;
-		}
-		
-		bool IsLocalVariable(string identifier)
-		{
-			foreach (CodeVariableDeclarationStatement variable in variables) {
-				if (variable.Name == identifier)
-					return true;
-			}
-
-			foreach (CodeParameterDeclarationExpression parameter in parameters)
-			{
-				if (parameter.Name == identifier)
-					return true;
-			}
-
-			return false;
-		}
-		
-		bool IsField(string identifier)
-		{
-			if (currentTypeDeclaration == null) // e.g. in unit tests
-				return false;
-			foreach (INode node in currentTypeDeclaration.Children) {
-				if (node is FieldDeclaration) {
-					FieldDeclaration fd = (FieldDeclaration)node;
-					if (fd.GetVariableDeclaration(identifier) != null) {
-						return true;
-					}
-				}
-			}
-			//field detection for fields\props inherited from base classes
-			if (currentTypeDeclaration.BaseTypes.Count > 0) {
-				return environmentInformationProvider.HasField(currentTypeDeclaration.BaseTypes[0].Type, currentTypeDeclaration.BaseTypes[0].GenericTypes.Count, identifier);
-			}
-			return false;
-		}
-		
-		static CodeTypeReferenceExpression ConvertToTypeReference(MemberReferenceExpression fieldReferenceExpression)
-		{
-			StringBuilder type = new StringBuilder("");
-			
-			while (fieldReferenceExpression.TargetObject is MemberReferenceExpression) {
-				type.Insert(0,'.');
-				type.Insert(1,fieldReferenceExpression.MemberName.ToCharArray());
-				fieldReferenceExpression = (MemberReferenceExpression)fieldReferenceExpression.TargetObject;
-			}
-			
-			type.Insert(0,'.');
-			type.Insert(1,fieldReferenceExpression.MemberName.ToCharArray());
-			
-			if (fieldReferenceExpression.TargetObject is IdentifierExpression) {
-				type.Insert(0, ((IdentifierExpression)fieldReferenceExpression.TargetObject).Identifier.ToCharArray());
-				string oldType = type.ToString();
-				int idx = oldType.LastIndexOf('.');
-				while (idx > 0) {
-					if (Type.GetType(type.ToString()) != null) {
-						break;
-					}
-					string stype = type.ToString().Substring(idx + 1);
-					type = new StringBuilder(type.ToString().Substring(0, idx));
-					type.Append("+");
-					type.Append(stype);
-					idx = type.ToString().LastIndexOf('.');
-				}
-				if (Type.GetType(type.ToString()) == null) {
-					type = new StringBuilder(oldType);
-				}
-				return new CodeTypeReferenceExpression(type.ToString());
-			} else if (fieldReferenceExpression.TargetObject is TypeReferenceExpression) {
-				type.Insert(0, ((TypeReferenceExpression)fieldReferenceExpression.TargetObject).TypeReference.Type);
-				return new CodeTypeReferenceExpression(type.ToString());
-			} else {
-				return null;
-			}
-		}
-		
-		CodeExpression[] GetExpressionList(IList expressionList)
-		{
-			if (expressionList == null) {
-				return new CodeExpression[0];
-			}
-			CodeExpression[] list = new CodeExpression[expressionList.Count];
-			for (int i = 0; i < expressionList.Count; ++i) {
-				list[i] = (CodeExpression)((Expression)expressionList[i]).AcceptVisitor(this, null);
-				if (list[i] == null) {
-					list[i] = new CodePrimitiveExpression(0);
-				}
-			}
-			return list;
-		}
-		
-		
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CodeDOMVerboseOutputGenerator.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CodeDOMVerboseOutputGenerator.cs
deleted file mode 100644
index 85b39a6ac..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/CodeDOMVerboseOutputGenerator.cs
+++ /dev/null
@@ -1,356 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.CodeDom;
-using System.CodeDom.Compiler;
-using System.IO;
-using System.Security.Permissions;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	[PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
-	[PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
-	public class CodeDomVerboseOutputGenerator : System.CodeDom.Compiler.CodeGenerator
-	{
-		#region System.CodeDom.Compiler.CodeGenerator abstract class implementation
-		protected override string NullToken {
-			get {
-				return "[NULL]";
-			}
-		}
-
-		protected override void OutputType(CodeTypeReference typeRef)
-		{
-			Output.Write("[CodeTypeReference: {0}", typeRef.BaseType);
-			if (typeRef.ArrayRank > 0) {
-				Output.Write(" Rank:" + typeRef.ArrayRank);
-			}
-			Output.Write("]");
-		}
-		
-		protected override void GenerateArrayCreateExpression(CodeArrayCreateExpression e)
-		{
-			Output.Write("[CodeArrayCreateExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateBaseReferenceExpression(CodeBaseReferenceExpression e)
-		{
-			Output.Write("[CodeBaseReferenceExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateCastExpression(CodeCastExpression e)
-		{
-			Output.Write("[CodeCastExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateDelegateCreateExpression(CodeDelegateCreateExpression e)
-		{
-			Output.Write("[CodeDelegateCreateExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateFieldReferenceExpression(CodeFieldReferenceExpression e)
-		{
-			Output.Write("[CodeFieldReferenceExpression: Name={0}, Target=", e.FieldName);
-			this.GenerateExpression(e.TargetObject);
-			Output.Write("]");
-		}
-		
-		protected override void GenerateMethodReferenceExpression(CodeMethodReferenceExpression e)
-		{
-			Output.Write("[CodeMethodReferenceExpression: Name={0}, Target=", e.MethodName);
-			this.GenerateExpression(e.TargetObject);
-			Output.Write("]");
-		}
-		
-		protected override void GenerateEventReferenceExpression(CodeEventReferenceExpression e)
-		{
-			Output.Write("[CodeEventReferenceExpression: Name={0}, Target=", e.EventName);
-			this.GenerateExpression(e.TargetObject);
-			Output.Write("]");
-		}
-		
-		protected override void GenerateArgumentReferenceExpression(CodeArgumentReferenceExpression e)
-		{
-			Output.Write("[CodeArgumentReferenceExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateVariableReferenceExpression(CodeVariableReferenceExpression e)
-		{
-			Output.Write("[CodeVariableReferenceExpression: Name={0}]", e.VariableName);
-		}
-		
-		protected override void GenerateIndexerExpression(CodeIndexerExpression e)
-		{
-			Output.Write("[CodeIndexerExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateArrayIndexerExpression(CodeArrayIndexerExpression e)
-		{
-			Output.Write("[CodeArrayIndexerExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateSnippetExpression(CodeSnippetExpression e)
-		{
-			Output.Write("[CodeSnippetExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateMethodInvokeExpression(CodeMethodInvokeExpression e)
-		{
-			Output.Write("[CodeMethodInvokeExpression: Method=");
-			GenerateMethodReferenceExpression(e.Method);
-			Output.Write(", Parameters=");
-			bool first = true;
-			foreach (CodeExpression expr in e.Parameters) {
-				if (first) first = false; else Output.Write(", ");
-				this.GenerateExpression(expr);
-			}
-			Output.Write("]");
-		}
-		
-		protected override void GenerateDelegateInvokeExpression(CodeDelegateInvokeExpression e)
-		{
-			Output.Write("[CodeDelegateInvokeExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateObjectCreateExpression(CodeObjectCreateExpression e)
-		{
-			Output.Write("[CodeObjectCreateExpression: Type={0}, Parameters=", e.CreateType.BaseType);
-			bool first = true;
-			foreach (CodeExpression expr in e.Parameters) {
-				if (first) first = false; else Output.Write(", ");
-				this.GenerateExpression(expr);
-			}
-			Output.Write("]");
-		}
-		
-		protected override void GeneratePropertyReferenceExpression(CodePropertyReferenceExpression e)
-		{
-			Output.Write("[CodePropertyReferenceExpression: Name={0}, Target=", e.PropertyName);
-			this.GenerateExpression(e.TargetObject);
-			Output.Write("]");
-		}
-		
-		protected override void GeneratePropertySetValueReferenceExpression(CodePropertySetValueReferenceExpression e)
-		{
-			Output.Write("[CodePropertySetValueReferenceExpression: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateThisReferenceExpression(CodeThisReferenceExpression e)
-		{
-			Output.Write("[CodeThisReferenceExpression]");
-		}
-		
-		protected override void GenerateExpressionStatement(CodeExpressionStatement e)
-		{
-			Output.Write("[CodeExpressionStatement:");
-			base.GenerateExpression(e.Expression);
-			Output.WriteLine("]");
-		}
-		
-		protected override void GenerateIterationStatement(CodeIterationStatement e)
-		{
-			Output.WriteLine("[CodeIterationStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateThrowExceptionStatement(CodeThrowExceptionStatement e)
-		{
-			Output.WriteLine("[CodeThrowExceptionStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateComment(CodeComment e)
-		{
-			Output.WriteLine("[CodeComment: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateMethodReturnStatement(CodeMethodReturnStatement e)
-		{
-			Output.WriteLine("[CodeMethodReturnStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateConditionStatement(CodeConditionStatement e)
-		{
-			Output.WriteLine("[GenerateConditionStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateTryCatchFinallyStatement(CodeTryCatchFinallyStatement e)
-		{
-			Output.WriteLine("[CodeTryCatchFinallyStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateAssignStatement(CodeAssignStatement e)
-		{
-			Output.Write("[CodeAssignStatement: Left=");
-			base.GenerateExpression(e.Left);
-			Output.Write(", Right=");
-			base.GenerateExpression(e.Right);
-			Output.WriteLine("]");
-		}
-		
-		protected override void GenerateAttachEventStatement(CodeAttachEventStatement e)
-		{
-			Output.WriteLine("[CodeAttachEventStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateRemoveEventStatement(CodeRemoveEventStatement e)
-		{
-			Output.WriteLine("[CodeRemoveEventStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateGotoStatement(CodeGotoStatement e)
-		{
-			Output.WriteLine("[CodeGotoStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateLabeledStatement(CodeLabeledStatement e)
-		{
-			Output.WriteLine("[CodeLabeledStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateVariableDeclarationStatement(CodeVariableDeclarationStatement e)
-		{
-			Output.WriteLine("[CodeVariableDeclarationStatement: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateLinePragmaStart(CodeLinePragma e)
-		{
-			Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateLinePragmaEnd(CodeLinePragma e)
-		{
-			Output.WriteLine("[CodeLinePragma: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateEvent(CodeMemberEvent e, CodeTypeDeclaration c)
-		{
-			Output.WriteLine("[CodeMemberEvent: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateField(CodeMemberField e)
-		{
-			Output.Write("[CodeMemberField: Name={0}, Type=", e.Name);
-			Output.Write(e.Type.BaseType);
-			Output.WriteLine("]");
-		}
-		
-		protected override void GenerateSnippetMember(CodeSnippetTypeMember e)
-		{
-			Output.WriteLine("[CodeSnippetTypeMember: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateEntryPointMethod(CodeEntryPointMethod e, CodeTypeDeclaration c)
-		{
-			Output.WriteLine("[CodeEntryPointMethod: {0}]", e.ToString());
-		}
-		
-		public void PublicGenerateCodeFromStatement(CodeStatement e, TextWriter w, CodeGeneratorOptions o)
-		{
-			((ICodeGenerator)this).GenerateCodeFromStatement(e, w, o);
-		}
-		
-		protected override void GenerateMethod(CodeMemberMethod e, CodeTypeDeclaration c)
-		{
-			Output.WriteLine("[CodeMemberMethod: Name={0}, Parameterns={1}]", e.Name, e.Parameters.Count);
-			++Indent;
-			GenerateStatements(e.Statements);
-			--Indent;
-		}
-		
-		protected override void GenerateProperty(CodeMemberProperty e, CodeTypeDeclaration c)
-		{
-			Output.WriteLine("[CodeMemberProperty : {0}]", e.ToString());
-		}
-		
-		protected override void GenerateConstructor(CodeConstructor e, CodeTypeDeclaration c)
-		{
-			Output.WriteLine("[CodeConstructor : {0}]", e.ToString());
-			++Indent;
-			GenerateStatements(e.Statements);
-			--Indent;
-		}
-		
-		protected override void GenerateTypeConstructor(CodeTypeConstructor e)
-		{
-			Output.WriteLine("[CodeTypeConstructor : {0}]", e.ToString());
-		}
-		
-		protected override void GenerateTypeStart(CodeTypeDeclaration e)
-		{
-			Output.WriteLine("[CodeTypeDeclaration : {0}]", e.ToString());
-		}
-		
-		protected override void GenerateTypeEnd(CodeTypeDeclaration e)
-		{
-			Output.WriteLine("[CodeTypeDeclaration: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateNamespaceStart(CodeNamespace e)
-		{
-			Output.WriteLine("[CodeNamespaceStart: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateNamespaceEnd(CodeNamespace e)
-		{
-			Output.WriteLine("[CodeNamespaceEnd: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateNamespaceImport(CodeNamespaceImport e)
-		{
-			Output.WriteLine("[CodeNamespaceImport: {0}]", e.ToString());
-		}
-		
-		protected override void GenerateAttributeDeclarationsStart(CodeAttributeDeclarationCollection attributes)
-		{
-			Output.WriteLine("[CodeAttributeDeclarationCollection: {0}]", attributes.ToString());
-		}
-		
-		protected override void GenerateAttributeDeclarationsEnd(CodeAttributeDeclarationCollection attributes)
-		{
-			Output.WriteLine("[CodeAttributeDeclarationCollection: {0}]", attributes.ToString());
-		}
-		
-		protected override void GeneratePrimitiveExpression(CodePrimitiveExpression e)
-		{
-			if (e.Value == null) {
-				Output.WriteLine("[CodePrimitiveExpression: null]");
-			} else {
-				Output.Write("[CodePrimitiveExpression: ");
-				base.GeneratePrimitiveExpression(e);
-				Output.WriteLine(" (" + e.Value.GetType().Name + ")]");
-			}
-		}
-		
-		protected override bool Supports(GeneratorSupport support)
-		{
-			return true;
-		}
-		
-		protected override bool IsValidIdentifier(string value)
-		{
-			return true;
-		}
-		
-		protected override string CreateEscapedIdentifier(string value)
-		{
-			return value;
-		}
-		
-		protected override string CreateValidIdentifier(string value)
-		{
-			return value;
-		}
-		
-		protected override string GetTypeOutput(CodeTypeReference value)
-		{
-			return value.ToString();
-		}
-		
-		protected override string QuoteSnippetString(string value)
-		{
-			return "\"" + value + "\"";
-		}
-		
-		#endregion
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs
deleted file mode 100644
index f29fe7f38..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/LookupTableVisitor.cs
+++ /dev/null
@@ -1,273 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	public sealed class LocalLookupVariable
-	{
-		public readonly string Name;
-		public readonly TypeReference TypeRef;
-		public readonly Location StartPos;
-		public readonly Location EndPos;
-		public readonly bool IsConst;
-		public readonly bool IsLoopVariable;
-		public readonly Expression Initializer;
-		public readonly LambdaExpression ParentLambdaExpression;
-		public readonly bool IsQueryContinuation;
-		
-		public LocalLookupVariable(string name, TypeReference typeRef, Location startPos, Location endPos, bool isConst, bool isLoopVariable, Expression initializer, LambdaExpression parentLambdaExpression, bool isQueryContinuation)
-		{
-			this.Name = name;
-			this.TypeRef = typeRef;
-			this.StartPos = startPos;
-			this.EndPos = endPos;
-			this.IsConst = isConst;
-			this.IsLoopVariable = isLoopVariable;
-			this.Initializer = initializer;
-			this.ParentLambdaExpression = parentLambdaExpression;
-			this.IsQueryContinuation = isQueryContinuation;
-		}
-		
-	}
-	
-	public sealed class LookupTableVisitor : AbstractAstVisitor
-	{
-		Dictionary<string, List<LocalLookupVariable>> variables;
-		
-		[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1006:DoNotNestGenericTypesInMemberSignatures")]
-		public Dictionary<string, List<LocalLookupVariable>> Variables {
-			get {
-				return variables;
-			}
-		}
-		
-		List<WithStatement> withStatements = new List<WithStatement>();
-		
-		public List<WithStatement> WithStatements {
-			get {
-				return withStatements;
-			}
-		}
-		
-		public LookupTableVisitor()
-		{
-			variables = new Dictionary<string, List<LocalLookupVariable>>(StringComparer.InvariantCultureIgnoreCase);
-		}
-		
-		public void AddVariable(TypeReference typeRef, string name,
-		                        Location startPos, Location endPos, bool isConst,
-		                        bool isLoopVariable, Expression initializer,
-		                        LambdaExpression parentLambdaExpression,
-		                        bool isQueryContinuation)
-		{
-			if (name == null || name.Length == 0) {
-				return;
-			}
-			List<LocalLookupVariable> list;
-			if (!variables.ContainsKey(name)) {
-				variables[name] = list = new List<LocalLookupVariable>();
-			} else {
-				list = (List<LocalLookupVariable>)variables[name];
-			}
-			list.Add(new LocalLookupVariable(name, typeRef, startPos, endPos, isConst, isLoopVariable, initializer, parentLambdaExpression, isQueryContinuation));
-		}
-		
-		public override object VisitWithStatement(WithStatement withStatement, object data)
-		{
-			withStatements.Add(withStatement);
-			return base.VisitWithStatement(withStatement, data);
-		}
-		
-		Stack<Location> endLocationStack = new Stack<Location>();
-		
-		Location CurrentEndLocation {
-			get {
-				return (endLocationStack.Count == 0) ? Location.Empty : endLocationStack.Peek();
-			}
-		}
-		
-		public override object VisitCompilationUnit (ICSharpCode.NRefactory.VB.Ast.CompilationUnit compilationUnit, object data)
-		{
-			variables.Clear ();
-			return base.VisitCompilationUnit (compilationUnit, data);
-		}
-		
-		public override object VisitBlockStatement(BlockStatement blockStatement, object data)
-		{
-			endLocationStack.Push(blockStatement.EndLocation);
-			base.VisitBlockStatement(blockStatement, data);
-			endLocationStack.Pop();
-			return null;
-		}
-		
-		public override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data)
-		{
-			for (int i = 0; i < localVariableDeclaration.Variables.Count; ++i) {
-				VariableDeclaration varDecl = (VariableDeclaration)localVariableDeclaration.Variables[i];
-				
-				AddVariable(localVariableDeclaration.GetTypeForVariable(i),
-				            varDecl.Name,
-				            localVariableDeclaration.StartLocation,
-				            CurrentEndLocation,
-				            (localVariableDeclaration.Modifier & Modifiers.Const) == Modifiers.Const,
-				            false, varDecl.Initializer, null, false);
-			}
-			return base.VisitLocalVariableDeclaration(localVariableDeclaration, data);
-		}
-		
-		public override object VisitLambdaExpression(LambdaExpression lambdaExpression, object data)
-		{
-			foreach (ParameterDeclarationExpression p in lambdaExpression.Parameters) {
-				AddVariable(p.TypeReference, p.ParameterName,
-				            lambdaExpression.StartLocation, lambdaExpression.ExtendedEndLocation,
-				            false, false, null, lambdaExpression, false);
-			}
-			return base.VisitLambdaExpression(lambdaExpression, data);
-		}
-		
-		public override object VisitQueryExpression(QueryExpression queryExpression, object data)
-		{
-			endLocationStack.Push(GetQueryVariableEndScope(queryExpression));
-			base.VisitQueryExpression(queryExpression, data);
-			endLocationStack.Pop();
-			return null;
-		}
-		
-		Location GetQueryVariableEndScope(QueryExpression queryExpression)
-		{
-			return queryExpression.EndLocation;
-		}
-		
-		public override object VisitQueryExpressionFromClause(QueryExpressionFromClause fromClause, object data)
-		{
-			// TODO : reimplement this!
-//			QueryExpression parent = fromClause.Parent as QueryExpression;
-//			foreach (CollectionRangeVariable variable in fromClause.Sources) {
-//				AddVariable(variable.Type, variable.Identifier,
-//				            variable.StartLocation, CurrentEndLocation,
-//				            false, true, variable.Expression, null, parent != null && parent.IsQueryContinuation);
-//			}
-
-			return base.VisitQueryExpressionFromClause(fromClause, data);
-		}
-		
-		public override object VisitQueryExpressionJoinClause(QueryExpressionJoinClause joinClause, object data)
-		{
-			if (string.IsNullOrEmpty(joinClause.IntoIdentifier)) {
-				AddVariable(joinClause.Source.Type, joinClause.Source.Identifier,
-				            joinClause.Source.StartLocation, CurrentEndLocation,
-				            false, true, joinClause.Source.Expression, null, false);
-			} else {
-				AddVariable(joinClause.Source.Type, joinClause.Source.Identifier,
-				            joinClause.Source.StartLocation, joinClause.Source.EndLocation,
-				            false, true, joinClause.Source.Expression, null, false);
-				
-				AddVariable(joinClause.Source.Type, joinClause.IntoIdentifier,
-				            joinClause.Source.StartLocation, CurrentEndLocation,
-				            false, false, joinClause.Source.Expression, null, false);
-			}
-			return base.VisitQueryExpressionJoinClause(joinClause, data);
-		}
-		
-		public override object VisitQueryExpressionLetClause(QueryExpressionLetClause letClause, object data)
-		{
-			AddVariable(null, letClause.Identifier,
-			            letClause.StartLocation, CurrentEndLocation,
-			            false, false, letClause.Expression, null, false);
-			return base.VisitQueryExpressionLetClause(letClause, data);
-		}
-		
-		public override object VisitForNextStatement(ForNextStatement forNextStatement, object data)
-		{
-			if (forNextStatement.EmbeddedStatement.EndLocation.IsEmpty) {
-				return base.VisitForNextStatement(forNextStatement, data);
-			} else {
-				endLocationStack.Push(forNextStatement.EmbeddedStatement.EndLocation);
-				AddVariable(forNextStatement.TypeReference,
-				            forNextStatement.VariableName,
-				            forNextStatement.StartLocation,
-				            forNextStatement.EndLocation,
-				            false, false,
-				            forNextStatement.Start,
-				            null,
-				            false);
-				
-				base.VisitForNextStatement(forNextStatement, data);
-				
-				endLocationStack.Pop();
-				return null;
-			}
-		}
-		
-		public override object VisitUsingStatement(UsingStatement usingStatement, object data)
-		{
-			// uses LocalVariableDeclaration, we just have to put the end location on the stack
-			if (usingStatement.EmbeddedStatement.EndLocation.IsEmpty) {
-				return base.VisitUsingStatement(usingStatement, data);
-			} else {
-				endLocationStack.Push(usingStatement.EmbeddedStatement.EndLocation);
-				base.VisitUsingStatement(usingStatement, data);
-				endLocationStack.Pop();
-				return null;
-			}
-		}
-		
-		public override object VisitSwitchSection(SwitchSection switchSection, object data)
-		{
-			return VisitBlockStatement(switchSection, data);
-		}
-		
-		public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
-		{
-			AddVariable(foreachStatement.TypeReference,
-			            foreachStatement.VariableName,
-			            foreachStatement.StartLocation,
-			            foreachStatement.EndLocation,
-			            false, true,
-			            foreachStatement.Expression,
-			            null,
-			            false);
-			
-			if (foreachStatement.Expression != null) {
-				foreachStatement.Expression.AcceptVisitor(this, data);
-			}
-			if (foreachStatement.EmbeddedStatement == null) {
-				return data;
-			}
-			return foreachStatement.EmbeddedStatement.AcceptVisitor(this, data);
-		}
-		
-		public override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data)
-		{
-			if (tryCatchStatement == null) {
-				return data;
-			}
-			if (tryCatchStatement.StatementBlock != null) {
-				tryCatchStatement.StatementBlock.AcceptVisitor(this, data);
-			}
-			if (tryCatchStatement.CatchClauses != null) {
-				foreach (CatchClause catchClause in tryCatchStatement.CatchClauses) {
-					if (catchClause != null) {
-						if (catchClause.TypeReference != null && catchClause.VariableName != null) {
-							AddVariable(catchClause.TypeReference,
-							            catchClause.VariableName,
-							            catchClause.StartLocation,
-							            catchClause.StatementBlock.EndLocation,
-							            false, false, null, null, false);
-						}
-						catchClause.StatementBlock.AcceptVisitor(this, data);
-					}
-				}
-			}
-			if (tryCatchStatement.FinallyBlock != null) {
-				return tryCatchStatement.FinallyBlock.AcceptVisitor(this, data);
-			}
-			return data;
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs
index 609d3b266..a94cb0333 100644
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NodeTrackingAstVisitor.cs
@@ -23,1244 +23,1244 @@ namespace ICSharpCode.NRefactory.VB.Visitors {
 	/// you want to visit child nodes using the default visiting behaviour,
 	/// use base.TrackedVisit(parentNode, data).
 	/// </remarks>
-	public abstract class NodeTrackingAstVisitor : AbstractAstVisitor {
-		
-		protected virtual void BeginVisit(INode node) {
-		}
-		
-		protected virtual void EndVisit(INode node) {
-		}
-		
-		public sealed override object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
-			this.BeginVisit(addHandlerStatement);
-			object result = this.TrackedVisitAddHandlerStatement(addHandlerStatement, data);
-			this.EndVisit(addHandlerStatement);
-			return result;
-		}
-		
-		public sealed override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
-			this.BeginVisit(addressOfExpression);
-			object result = this.TrackedVisitAddressOfExpression(addressOfExpression, data);
-			this.EndVisit(addressOfExpression);
-			return result;
-		}
-		
-		public sealed override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
-			this.BeginVisit(arrayCreateExpression);
-			object result = this.TrackedVisitArrayCreateExpression(arrayCreateExpression, data);
-			this.EndVisit(arrayCreateExpression);
-			return result;
-		}
-		
-		public sealed override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
-			this.BeginVisit(assignmentExpression);
-			object result = this.TrackedVisitAssignmentExpression(assignmentExpression, data);
-			this.EndVisit(assignmentExpression);
-			return result;
-		}
-		
-		public sealed override object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
-			this.BeginVisit(attribute);
-			object result = this.TrackedVisitAttribute(attribute, data);
-			this.EndVisit(attribute);
-			return result;
-		}
-		
-		public sealed override object VisitAttributeSection(AttributeSection attributeSection, object data) {
-			this.BeginVisit(attributeSection);
-			object result = this.TrackedVisitAttributeSection(attributeSection, data);
-			this.EndVisit(attributeSection);
-			return result;
-		}
-		
-		public sealed override object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
-			this.BeginVisit(baseReferenceExpression);
-			object result = this.TrackedVisitBaseReferenceExpression(baseReferenceExpression, data);
-			this.EndVisit(baseReferenceExpression);
-			return result;
-		}
-		
-		public sealed override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
-			this.BeginVisit(binaryOperatorExpression);
-			object result = this.TrackedVisitBinaryOperatorExpression(binaryOperatorExpression, data);
-			this.EndVisit(binaryOperatorExpression);
-			return result;
-		}
-		
-		public sealed override object VisitBlockStatement(BlockStatement blockStatement, object data) {
-			this.BeginVisit(blockStatement);
-			object result = this.TrackedVisitBlockStatement(blockStatement, data);
-			this.EndVisit(blockStatement);
-			return result;
-		}
-		
-		public sealed override object VisitCaseLabel(CaseLabel caseLabel, object data) {
-			this.BeginVisit(caseLabel);
-			object result = this.TrackedVisitCaseLabel(caseLabel, data);
-			this.EndVisit(caseLabel);
-			return result;
-		}
-		
-		public sealed override object VisitCastExpression(CastExpression castExpression, object data) {
-			this.BeginVisit(castExpression);
-			object result = this.TrackedVisitCastExpression(castExpression, data);
-			this.EndVisit(castExpression);
-			return result;
-		}
-		
-		public sealed override object VisitCatchClause(CatchClause catchClause, object data) {
-			this.BeginVisit(catchClause);
-			object result = this.TrackedVisitCatchClause(catchClause, data);
-			this.EndVisit(catchClause);
-			return result;
-		}
-		
-		public sealed override object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
-			this.BeginVisit(classReferenceExpression);
-			object result = this.TrackedVisitClassReferenceExpression(classReferenceExpression, data);
-			this.EndVisit(classReferenceExpression);
-			return result;
-		}
-		
-		public sealed override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
-			this.BeginVisit(collectionInitializerExpression);
-			object result = this.TrackedVisitCollectionInitializerExpression(collectionInitializerExpression, data);
-			this.EndVisit(collectionInitializerExpression);
-			return result;
-		}
-		
-		public sealed override object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
-			this.BeginVisit(collectionRangeVariable);
-			object result = this.TrackedVisitCollectionRangeVariable(collectionRangeVariable, data);
-			this.EndVisit(collectionRangeVariable);
-			return result;
-		}
-		
-		public sealed override object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
-			this.BeginVisit(compilationUnit);
-			object result = this.TrackedVisitCompilationUnit(compilationUnit, data);
-			this.EndVisit(compilationUnit);
-			return result;
-		}
-		
-		public sealed override object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
-			this.BeginVisit(conditionalExpression);
-			object result = this.TrackedVisitConditionalExpression(conditionalExpression, data);
-			this.EndVisit(conditionalExpression);
-			return result;
-		}
-		
-		public sealed override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
-			this.BeginVisit(constructorDeclaration);
-			object result = this.TrackedVisitConstructorDeclaration(constructorDeclaration, data);
-			this.EndVisit(constructorDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
-			this.BeginVisit(constructorInitializer);
-			object result = this.TrackedVisitConstructorInitializer(constructorInitializer, data);
-			this.EndVisit(constructorInitializer);
-			return result;
-		}
-		
-		public sealed override object VisitContinueStatement(ContinueStatement continueStatement, object data) {
-			this.BeginVisit(continueStatement);
-			object result = this.TrackedVisitContinueStatement(continueStatement, data);
-			this.EndVisit(continueStatement);
-			return result;
-		}
-		
-		public sealed override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
-			this.BeginVisit(declareDeclaration);
-			object result = this.TrackedVisitDeclareDeclaration(declareDeclaration, data);
-			this.EndVisit(declareDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
-			this.BeginVisit(defaultValueExpression);
-			object result = this.TrackedVisitDefaultValueExpression(defaultValueExpression, data);
-			this.EndVisit(defaultValueExpression);
-			return result;
-		}
-		
-		public sealed override object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
-			this.BeginVisit(delegateDeclaration);
-			object result = this.TrackedVisitDelegateDeclaration(delegateDeclaration, data);
-			this.EndVisit(delegateDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
-			this.BeginVisit(directionExpression);
-			object result = this.TrackedVisitDirectionExpression(directionExpression, data);
-			this.EndVisit(directionExpression);
-			return result;
-		}
-		
-		public sealed override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
-			this.BeginVisit(doLoopStatement);
-			object result = this.TrackedVisitDoLoopStatement(doLoopStatement, data);
-			this.EndVisit(doLoopStatement);
-			return result;
-		}
-		
-		public sealed override object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
-			this.BeginVisit(elseIfSection);
-			object result = this.TrackedVisitElseIfSection(elseIfSection, data);
-			this.EndVisit(elseIfSection);
-			return result;
-		}
-		
-		public sealed override object VisitEndStatement(EndStatement endStatement, object data) {
-			this.BeginVisit(endStatement);
-			object result = this.TrackedVisitEndStatement(endStatement, data);
-			this.EndVisit(endStatement);
-			return result;
-		}
-		
-		public sealed override object VisitEraseStatement(EraseStatement eraseStatement, object data) {
-			this.BeginVisit(eraseStatement);
-			object result = this.TrackedVisitEraseStatement(eraseStatement, data);
-			this.EndVisit(eraseStatement);
-			return result;
-		}
-		
-		public sealed override object VisitErrorStatement(ErrorStatement errorStatement, object data) {
-			this.BeginVisit(errorStatement);
-			object result = this.TrackedVisitErrorStatement(errorStatement, data);
-			this.EndVisit(errorStatement);
-			return result;
-		}
-		
-		public sealed override object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
-			this.BeginVisit(eventAddRegion);
-			object result = this.TrackedVisitEventAddRegion(eventAddRegion, data);
-			this.EndVisit(eventAddRegion);
-			return result;
-		}
-		
-		public sealed override object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
-			this.BeginVisit(eventDeclaration);
-			object result = this.TrackedVisitEventDeclaration(eventDeclaration, data);
-			this.EndVisit(eventDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
-			this.BeginVisit(eventRaiseRegion);
-			object result = this.TrackedVisitEventRaiseRegion(eventRaiseRegion, data);
-			this.EndVisit(eventRaiseRegion);
-			return result;
-		}
-		
-		public sealed override object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
-			this.BeginVisit(eventRemoveRegion);
-			object result = this.TrackedVisitEventRemoveRegion(eventRemoveRegion, data);
-			this.EndVisit(eventRemoveRegion);
-			return result;
-		}
-		
-		public sealed override object VisitExitStatement(ExitStatement exitStatement, object data) {
-			this.BeginVisit(exitStatement);
-			object result = this.TrackedVisitExitStatement(exitStatement, data);
-			this.EndVisit(exitStatement);
-			return result;
-		}
-		
-		public sealed override object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
-			this.BeginVisit(expressionRangeVariable);
-			object result = this.TrackedVisitExpressionRangeVariable(expressionRangeVariable, data);
-			this.EndVisit(expressionRangeVariable);
-			return result;
-		}
-		
-		public sealed override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
-			this.BeginVisit(expressionStatement);
-			object result = this.TrackedVisitExpressionStatement(expressionStatement, data);
-			this.EndVisit(expressionStatement);
-			return result;
-		}
-		
-		public sealed override object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
-			this.BeginVisit(externAliasDirective);
-			object result = this.TrackedVisitExternAliasDirective(externAliasDirective, data);
-			this.EndVisit(externAliasDirective);
-			return result;
-		}
-		
-		public sealed override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
-			this.BeginVisit(fieldDeclaration);
-			object result = this.TrackedVisitFieldDeclaration(fieldDeclaration, data);
-			this.EndVisit(fieldDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
-			this.BeginVisit(foreachStatement);
-			object result = this.TrackedVisitForeachStatement(foreachStatement, data);
-			this.EndVisit(foreachStatement);
-			return result;
-		}
-		
-		public sealed override object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
-			this.BeginVisit(forNextStatement);
-			object result = this.TrackedVisitForNextStatement(forNextStatement, data);
-			this.EndVisit(forNextStatement);
-			return result;
-		}
-		
-		public sealed override object VisitGotoStatement(GotoStatement gotoStatement, object data) {
-			this.BeginVisit(gotoStatement);
-			object result = this.TrackedVisitGotoStatement(gotoStatement, data);
-			this.EndVisit(gotoStatement);
-			return result;
-		}
-		
-		public sealed override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
-			this.BeginVisit(identifierExpression);
-			object result = this.TrackedVisitIdentifierExpression(identifierExpression, data);
-			this.EndVisit(identifierExpression);
-			return result;
-		}
-		
-		public sealed override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
-			this.BeginVisit(ifElseStatement);
-			object result = this.TrackedVisitIfElseStatement(ifElseStatement, data);
-			this.EndVisit(ifElseStatement);
-			return result;
-		}
-		
-		public sealed override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
-			this.BeginVisit(innerClassTypeReference);
-			object result = this.TrackedVisitInnerClassTypeReference(innerClassTypeReference, data);
-			this.EndVisit(innerClassTypeReference);
-			return result;
-		}
-		
-		public sealed override object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
-			this.BeginVisit(interfaceImplementation);
-			object result = this.TrackedVisitInterfaceImplementation(interfaceImplementation, data);
-			this.EndVisit(interfaceImplementation);
-			return result;
-		}
-		
-		public sealed override object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
-			this.BeginVisit(invocationExpression);
-			object result = this.TrackedVisitInvocationExpression(invocationExpression, data);
-			this.EndVisit(invocationExpression);
-			return result;
-		}
-		
-		public sealed override object VisitLabelStatement(LabelStatement labelStatement, object data) {
-			this.BeginVisit(labelStatement);
-			object result = this.TrackedVisitLabelStatement(labelStatement, data);
-			this.EndVisit(labelStatement);
-			return result;
-		}
-		
-		public sealed override object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
-			this.BeginVisit(lambdaExpression);
-			object result = this.TrackedVisitLambdaExpression(lambdaExpression, data);
-			this.EndVisit(lambdaExpression);
-			return result;
-		}
-		
-		public sealed override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
-			this.BeginVisit(localVariableDeclaration);
-			object result = this.TrackedVisitLocalVariableDeclaration(localVariableDeclaration, data);
-			this.EndVisit(localVariableDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitLockStatement(LockStatement lockStatement, object data) {
-			this.BeginVisit(lockStatement);
-			object result = this.TrackedVisitLockStatement(lockStatement, data);
-			this.EndVisit(lockStatement);
-			return result;
-		}
-		
-		public sealed override object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
-			this.BeginVisit(memberInitializerExpression);
-			object result = this.TrackedVisitMemberInitializerExpression(memberInitializerExpression, data);
-			this.EndVisit(memberInitializerExpression);
-			return result;
-		}
-		
-		public sealed override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
-			this.BeginVisit(memberReferenceExpression);
-			object result = this.TrackedVisitMemberReferenceExpression(memberReferenceExpression, data);
-			this.EndVisit(memberReferenceExpression);
-			return result;
-		}
-		
-		public sealed override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
-			this.BeginVisit(methodDeclaration);
-			object result = this.TrackedVisitMethodDeclaration(methodDeclaration, data);
-			this.EndVisit(methodDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
-			this.BeginVisit(namedArgumentExpression);
-			object result = this.TrackedVisitNamedArgumentExpression(namedArgumentExpression, data);
-			this.EndVisit(namedArgumentExpression);
-			return result;
-		}
-		
-		public sealed override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
-			this.BeginVisit(namespaceDeclaration);
-			object result = this.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
-			this.EndVisit(namespaceDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
-			this.BeginVisit(objectCreateExpression);
-			object result = this.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
-			this.EndVisit(objectCreateExpression);
-			return result;
-		}
-		
-		public sealed override object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
-			this.BeginVisit(onErrorStatement);
-			object result = this.TrackedVisitOnErrorStatement(onErrorStatement, data);
-			this.EndVisit(onErrorStatement);
-			return result;
-		}
-		
-		public sealed override object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
-			this.BeginVisit(operatorDeclaration);
-			object result = this.TrackedVisitOperatorDeclaration(operatorDeclaration, data);
-			this.EndVisit(operatorDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
-			this.BeginVisit(optionDeclaration);
-			object result = this.TrackedVisitOptionDeclaration(optionDeclaration, data);
-			this.EndVisit(optionDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
-			this.BeginVisit(parameterDeclarationExpression);
-			object result = this.TrackedVisitParameterDeclarationExpression(parameterDeclarationExpression, data);
-			this.EndVisit(parameterDeclarationExpression);
-			return result;
-		}
-		
-		public sealed override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
-			this.BeginVisit(parenthesizedExpression);
-			object result = this.TrackedVisitParenthesizedExpression(parenthesizedExpression, data);
-			this.EndVisit(parenthesizedExpression);
-			return result;
-		}
-		
-		public sealed override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
-			this.BeginVisit(primitiveExpression);
-			object result = this.TrackedVisitPrimitiveExpression(primitiveExpression, data);
-			this.EndVisit(primitiveExpression);
-			return result;
-		}
-		
-		public sealed override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
-			this.BeginVisit(propertyDeclaration);
-			object result = this.TrackedVisitPropertyDeclaration(propertyDeclaration, data);
-			this.EndVisit(propertyDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
-			this.BeginVisit(propertyGetRegion);
-			object result = this.TrackedVisitPropertyGetRegion(propertyGetRegion, data);
-			this.EndVisit(propertyGetRegion);
-			return result;
-		}
-		
-		public sealed override object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
-			this.BeginVisit(propertySetRegion);
-			object result = this.TrackedVisitPropertySetRegion(propertySetRegion, data);
-			this.EndVisit(propertySetRegion);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpression(QueryExpression queryExpression, object data) {
-			this.BeginVisit(queryExpression);
-			object result = this.TrackedVisitQueryExpression(queryExpression, data);
-			this.EndVisit(queryExpression);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
-			this.BeginVisit(queryExpressionAggregateClause);
-			object result = this.TrackedVisitQueryExpressionAggregateClause(queryExpressionAggregateClause, data);
-			this.EndVisit(queryExpressionAggregateClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
-			this.BeginVisit(queryExpressionDistinctClause);
-			object result = this.TrackedVisitQueryExpressionDistinctClause(queryExpressionDistinctClause, data);
-			this.EndVisit(queryExpressionDistinctClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
-			this.BeginVisit(queryExpressionFromClause);
-			object result = this.TrackedVisitQueryExpressionFromClause(queryExpressionFromClause, data);
-			this.EndVisit(queryExpressionFromClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
-			this.BeginVisit(queryExpressionGroupClause);
-			object result = this.TrackedVisitQueryExpressionGroupClause(queryExpressionGroupClause, data);
-			this.EndVisit(queryExpressionGroupClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
-			this.BeginVisit(queryExpressionGroupJoinVBClause);
-			object result = this.TrackedVisitQueryExpressionGroupJoinVBClause(queryExpressionGroupJoinVBClause, data);
-			this.EndVisit(queryExpressionGroupJoinVBClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
-			this.BeginVisit(queryExpressionGroupVBClause);
-			object result = this.TrackedVisitQueryExpressionGroupVBClause(queryExpressionGroupVBClause, data);
-			this.EndVisit(queryExpressionGroupVBClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
-			this.BeginVisit(queryExpressionJoinClause);
-			object result = this.TrackedVisitQueryExpressionJoinClause(queryExpressionJoinClause, data);
-			this.EndVisit(queryExpressionJoinClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
-			this.BeginVisit(queryExpressionJoinConditionVB);
-			object result = this.TrackedVisitQueryExpressionJoinConditionVB(queryExpressionJoinConditionVB, data);
-			this.EndVisit(queryExpressionJoinConditionVB);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
-			this.BeginVisit(queryExpressionJoinVBClause);
-			object result = this.TrackedVisitQueryExpressionJoinVBClause(queryExpressionJoinVBClause, data);
-			this.EndVisit(queryExpressionJoinVBClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
-			this.BeginVisit(queryExpressionLetClause);
-			object result = this.TrackedVisitQueryExpressionLetClause(queryExpressionLetClause, data);
-			this.EndVisit(queryExpressionLetClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionLetVBClause(QueryExpressionLetVBClause queryExpressionLetVBClause, object data) {
-			this.BeginVisit(queryExpressionLetVBClause);
-			object result = this.TrackedVisitQueryExpressionLetVBClause(queryExpressionLetVBClause, data);
-			this.EndVisit(queryExpressionLetVBClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
-			this.BeginVisit(queryExpressionOrderClause);
-			object result = this.TrackedVisitQueryExpressionOrderClause(queryExpressionOrderClause, data);
-			this.EndVisit(queryExpressionOrderClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
-			this.BeginVisit(queryExpressionOrdering);
-			object result = this.TrackedVisitQueryExpressionOrdering(queryExpressionOrdering, data);
-			this.EndVisit(queryExpressionOrdering);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
-			this.BeginVisit(queryExpressionPartitionVBClause);
-			object result = this.TrackedVisitQueryExpressionPartitionVBClause(queryExpressionPartitionVBClause, data);
-			this.EndVisit(queryExpressionPartitionVBClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
-			this.BeginVisit(queryExpressionSelectClause);
-			object result = this.TrackedVisitQueryExpressionSelectClause(queryExpressionSelectClause, data);
-			this.EndVisit(queryExpressionSelectClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
-			this.BeginVisit(queryExpressionSelectVBClause);
-			object result = this.TrackedVisitQueryExpressionSelectVBClause(queryExpressionSelectVBClause, data);
-			this.EndVisit(queryExpressionSelectVBClause);
-			return result;
-		}
-		
-		public sealed override object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
-			this.BeginVisit(queryExpressionWhereClause);
-			object result = this.TrackedVisitQueryExpressionWhereClause(queryExpressionWhereClause, data);
-			this.EndVisit(queryExpressionWhereClause);
-			return result;
-		}
-		
-		public sealed override object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
-			this.BeginVisit(raiseEventStatement);
-			object result = this.TrackedVisitRaiseEventStatement(raiseEventStatement, data);
-			this.EndVisit(raiseEventStatement);
-			return result;
-		}
-		
-		public sealed override object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
-			this.BeginVisit(reDimStatement);
-			object result = this.TrackedVisitReDimStatement(reDimStatement, data);
-			this.EndVisit(reDimStatement);
-			return result;
-		}
-		
-		public sealed override object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
-			this.BeginVisit(removeHandlerStatement);
-			object result = this.TrackedVisitRemoveHandlerStatement(removeHandlerStatement, data);
-			this.EndVisit(removeHandlerStatement);
-			return result;
-		}
-		
-		public sealed override object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
-			this.BeginVisit(resumeStatement);
-			object result = this.TrackedVisitResumeStatement(resumeStatement, data);
-			this.EndVisit(resumeStatement);
-			return result;
-		}
-		
-		public sealed override object VisitReturnStatement(ReturnStatement returnStatement, object data) {
-			this.BeginVisit(returnStatement);
-			object result = this.TrackedVisitReturnStatement(returnStatement, data);
-			this.EndVisit(returnStatement);
-			return result;
-		}
-		
-		public sealed override object VisitStopStatement(StopStatement stopStatement, object data) {
-			this.BeginVisit(stopStatement);
-			object result = this.TrackedVisitStopStatement(stopStatement, data);
-			this.EndVisit(stopStatement);
-			return result;
-		}
-		
-		public sealed override object VisitSwitchSection(SwitchSection switchSection, object data) {
-			this.BeginVisit(switchSection);
-			object result = this.TrackedVisitSwitchSection(switchSection, data);
-			this.EndVisit(switchSection);
-			return result;
-		}
-		
-		public sealed override object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
-			this.BeginVisit(switchStatement);
-			object result = this.TrackedVisitSwitchStatement(switchStatement, data);
-			this.EndVisit(switchStatement);
-			return result;
-		}
-		
-		public sealed override object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
-			this.BeginVisit(templateDefinition);
-			object result = this.TrackedVisitTemplateDefinition(templateDefinition, data);
-			this.EndVisit(templateDefinition);
-			return result;
-		}
-		
-		public sealed override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
-			this.BeginVisit(thisReferenceExpression);
-			object result = this.TrackedVisitThisReferenceExpression(thisReferenceExpression, data);
-			this.EndVisit(thisReferenceExpression);
-			return result;
-		}
-		
-		public sealed override object VisitThrowStatement(ThrowStatement throwStatement, object data) {
-			this.BeginVisit(throwStatement);
-			object result = this.TrackedVisitThrowStatement(throwStatement, data);
-			this.EndVisit(throwStatement);
-			return result;
-		}
-		
-		public sealed override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
-			this.BeginVisit(tryCatchStatement);
-			object result = this.TrackedVisitTryCatchStatement(tryCatchStatement, data);
-			this.EndVisit(tryCatchStatement);
-			return result;
-		}
-		
-		public sealed override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
-			this.BeginVisit(typeDeclaration);
-			object result = this.TrackedVisitTypeDeclaration(typeDeclaration, data);
-			this.EndVisit(typeDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
-			this.BeginVisit(typeOfExpression);
-			object result = this.TrackedVisitTypeOfExpression(typeOfExpression, data);
-			this.EndVisit(typeOfExpression);
-			return result;
-		}
-		
-		public sealed override object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
-			this.BeginVisit(typeOfIsExpression);
-			object result = this.TrackedVisitTypeOfIsExpression(typeOfIsExpression, data);
-			this.EndVisit(typeOfIsExpression);
-			return result;
-		}
-		
-		public sealed override object VisitTypeReference(TypeReference typeReference, object data) {
-			this.BeginVisit(typeReference);
-			object result = this.TrackedVisitTypeReference(typeReference, data);
-			this.EndVisit(typeReference);
-			return result;
-		}
-		
-		public sealed override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
-			this.BeginVisit(typeReferenceExpression);
-			object result = this.TrackedVisitTypeReferenceExpression(typeReferenceExpression, data);
-			this.EndVisit(typeReferenceExpression);
-			return result;
-		}
-		
-		public sealed override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
-			this.BeginVisit(unaryOperatorExpression);
-			object result = this.TrackedVisitUnaryOperatorExpression(unaryOperatorExpression, data);
-			this.EndVisit(unaryOperatorExpression);
-			return result;
-		}
-		
-		public sealed override object VisitUsing(Using @using, object data) {
-			this.BeginVisit(@using);
-			object result = this.TrackedVisitUsing(@using, data);
-			this.EndVisit(@using);
-			return result;
-		}
-		
-		public sealed override object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
-			this.BeginVisit(usingDeclaration);
-			object result = this.TrackedVisitUsingDeclaration(usingDeclaration, data);
-			this.EndVisit(usingDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitUsingStatement(UsingStatement usingStatement, object data) {
-			this.BeginVisit(usingStatement);
-			object result = this.TrackedVisitUsingStatement(usingStatement, data);
-			this.EndVisit(usingStatement);
-			return result;
-		}
-		
-		public sealed override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
-			this.BeginVisit(variableDeclaration);
-			object result = this.TrackedVisitVariableDeclaration(variableDeclaration, data);
-			this.EndVisit(variableDeclaration);
-			return result;
-		}
-		
-		public sealed override object VisitWithStatement(WithStatement withStatement, object data) {
-			this.BeginVisit(withStatement);
-			object result = this.TrackedVisitWithStatement(withStatement, data);
-			this.EndVisit(withStatement);
-			return result;
-		}
-		
-		public sealed override object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
-			this.BeginVisit(xmlAttributeExpression);
-			object result = this.TrackedVisitXmlAttributeExpression(xmlAttributeExpression, data);
-			this.EndVisit(xmlAttributeExpression);
-			return result;
-		}
-		
-		public sealed override object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
-			this.BeginVisit(xmlContentExpression);
-			object result = this.TrackedVisitXmlContentExpression(xmlContentExpression, data);
-			this.EndVisit(xmlContentExpression);
-			return result;
-		}
-		
-		public sealed override object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
-			this.BeginVisit(xmlDocumentExpression);
-			object result = this.TrackedVisitXmlDocumentExpression(xmlDocumentExpression, data);
-			this.EndVisit(xmlDocumentExpression);
-			return result;
-		}
-		
-		public sealed override object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
-			this.BeginVisit(xmlElementExpression);
-			object result = this.TrackedVisitXmlElementExpression(xmlElementExpression, data);
-			this.EndVisit(xmlElementExpression);
-			return result;
-		}
-		
-		public sealed override object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
-			this.BeginVisit(xmlEmbeddedExpression);
-			object result = this.TrackedVisitXmlEmbeddedExpression(xmlEmbeddedExpression, data);
-			this.EndVisit(xmlEmbeddedExpression);
-			return result;
-		}
-		
-		public sealed override object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
-			this.BeginVisit(xmlMemberAccessExpression);
-			object result = this.TrackedVisitXmlMemberAccessExpression(xmlMemberAccessExpression, data);
-			this.EndVisit(xmlMemberAccessExpression);
-			return result;
-		}
-		
-		public virtual object TrackedVisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
-			return base.VisitAddHandlerStatement(addHandlerStatement, data);
-		}
-		
-		public virtual object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
-			return base.VisitAddressOfExpression(addressOfExpression, data);
-		}
-		
-		public virtual object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
-			return base.VisitArrayCreateExpression(arrayCreateExpression, data);
-		}
-		
-		public virtual object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
-			return base.VisitAssignmentExpression(assignmentExpression, data);
-		}
-		
-		public virtual object TrackedVisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
-			return base.VisitAttribute(attribute, data);
-		}
-		
-		public virtual object TrackedVisitAttributeSection(AttributeSection attributeSection, object data) {
-			return base.VisitAttributeSection(attributeSection, data);
-		}
-		
-		public virtual object TrackedVisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
-			return base.VisitBaseReferenceExpression(baseReferenceExpression, data);
-		}
-		
-		public virtual object TrackedVisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
-			return base.VisitBinaryOperatorExpression(binaryOperatorExpression, data);
-		}
-		
-		public virtual object TrackedVisitBlockStatement(BlockStatement blockStatement, object data) {
-			return base.VisitBlockStatement(blockStatement, data);
-		}
-		
-		public virtual object TrackedVisitCaseLabel(CaseLabel caseLabel, object data) {
-			return base.VisitCaseLabel(caseLabel, data);
-		}
-		
-		public virtual object TrackedVisitCastExpression(CastExpression castExpression, object data) {
-			return base.VisitCastExpression(castExpression, data);
-		}
-		
-		public virtual object TrackedVisitCatchClause(CatchClause catchClause, object data) {
-			return base.VisitCatchClause(catchClause, data);
-		}
-		
-		public virtual object TrackedVisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
-			return base.VisitClassReferenceExpression(classReferenceExpression, data);
-		}
-		
-		public virtual object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
-			return base.VisitCollectionInitializerExpression(collectionInitializerExpression, data);
-		}
-		
-		public virtual object TrackedVisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
-			return base.VisitCollectionRangeVariable(collectionRangeVariable, data);
-		}
-		
-		public virtual object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data) {
-			return base.VisitCompilationUnit(compilationUnit, data);
-		}
-		
-		public virtual object TrackedVisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
-			return base.VisitConditionalExpression(conditionalExpression, data);
-		}
-		
-		public virtual object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
-			return base.VisitConstructorDeclaration(constructorDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
-			return base.VisitConstructorInitializer(constructorInitializer, data);
-		}
-		
-		public virtual object TrackedVisitContinueStatement(ContinueStatement continueStatement, object data) {
-			return base.VisitContinueStatement(continueStatement, data);
-		}
-		
-		public virtual object TrackedVisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
-			return base.VisitDeclareDeclaration(declareDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
-			return base.VisitDefaultValueExpression(defaultValueExpression, data);
-		}
-		
-		public virtual object TrackedVisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
-			return base.VisitDelegateDeclaration(delegateDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitDirectionExpression(DirectionExpression directionExpression, object data) {
-			return base.VisitDirectionExpression(directionExpression, data);
-		}
-		
-		public virtual object TrackedVisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
-			return base.VisitDoLoopStatement(doLoopStatement, data);
-		}
-		
-		public virtual object TrackedVisitElseIfSection(ElseIfSection elseIfSection, object data) {
-			return base.VisitElseIfSection(elseIfSection, data);
-		}
-		
-		public virtual object TrackedVisitEndStatement(EndStatement endStatement, object data) {
-			return base.VisitEndStatement(endStatement, data);
-		}
-		
-		public virtual object TrackedVisitEraseStatement(EraseStatement eraseStatement, object data) {
-			return base.VisitEraseStatement(eraseStatement, data);
-		}
-		
-		public virtual object TrackedVisitErrorStatement(ErrorStatement errorStatement, object data) {
-			return base.VisitErrorStatement(errorStatement, data);
-		}
-		
-		public virtual object TrackedVisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
-			return base.VisitEventAddRegion(eventAddRegion, data);
-		}
-		
-		public virtual object TrackedVisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
-			return base.VisitEventDeclaration(eventDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
-			return base.VisitEventRaiseRegion(eventRaiseRegion, data);
-		}
-		
-		public virtual object TrackedVisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
-			return base.VisitEventRemoveRegion(eventRemoveRegion, data);
-		}
-		
-		public virtual object TrackedVisitExitStatement(ExitStatement exitStatement, object data) {
-			return base.VisitExitStatement(exitStatement, data);
-		}
-		
-		public virtual object TrackedVisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
-			return base.VisitExpressionRangeVariable(expressionRangeVariable, data);
-		}
-		
-		public virtual object TrackedVisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
-			return base.VisitExpressionStatement(expressionStatement, data);
-		}
-		
-		public virtual object TrackedVisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
-			return base.VisitExternAliasDirective(externAliasDirective, data);
-		}
-		
-		public virtual object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
-			return base.VisitFieldDeclaration(fieldDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitForeachStatement(ForeachStatement foreachStatement, object data) {
-			return base.VisitForeachStatement(foreachStatement, data);
-		}
-		
-		public virtual object TrackedVisitForNextStatement(ForNextStatement forNextStatement, object data) {
-			return base.VisitForNextStatement(forNextStatement, data);
-		}
-		
-		public virtual object TrackedVisitGotoStatement(GotoStatement gotoStatement, object data) {
-			return base.VisitGotoStatement(gotoStatement, data);
-		}
-		
-		public virtual object TrackedVisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
-			return base.VisitIdentifierExpression(identifierExpression, data);
-		}
-		
-		public virtual object TrackedVisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
-			return base.VisitIfElseStatement(ifElseStatement, data);
-		}
-		
-		public virtual object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
-			return base.VisitInnerClassTypeReference(innerClassTypeReference, data);
-		}
-		
-		public virtual object TrackedVisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
-			return base.VisitInterfaceImplementation(interfaceImplementation, data);
-		}
-		
-		public virtual object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data) {
-			return base.VisitInvocationExpression(invocationExpression, data);
-		}
-		
-		public virtual object TrackedVisitLabelStatement(LabelStatement labelStatement, object data) {
-			return base.VisitLabelStatement(labelStatement, data);
-		}
-		
-		public virtual object TrackedVisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
-			return base.VisitLambdaExpression(lambdaExpression, data);
-		}
-		
-		public virtual object TrackedVisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
-			return base.VisitLocalVariableDeclaration(localVariableDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitLockStatement(LockStatement lockStatement, object data) {
-			return base.VisitLockStatement(lockStatement, data);
-		}
-		
-		public virtual object TrackedVisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
-			return base.VisitMemberInitializerExpression(memberInitializerExpression, data);
-		}
-		
-		public virtual object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
-			return base.VisitMemberReferenceExpression(memberReferenceExpression, data);
-		}
-		
-		public virtual object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
-			return base.VisitMethodDeclaration(methodDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
-			return base.VisitNamedArgumentExpression(namedArgumentExpression, data);
-		}
-		
-		public virtual object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
-			return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
-			return base.VisitObjectCreateExpression(objectCreateExpression, data);
-		}
-		
-		public virtual object TrackedVisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
-			return base.VisitOnErrorStatement(onErrorStatement, data);
-		}
-		
-		public virtual object TrackedVisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
-			return base.VisitOperatorDeclaration(operatorDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
-			return base.VisitOptionDeclaration(optionDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
-			return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data);
-		}
-		
-		public virtual object TrackedVisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
-			return base.VisitParenthesizedExpression(parenthesizedExpression, data);
-		}
-		
-		public virtual object TrackedVisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
-			return base.VisitPrimitiveExpression(primitiveExpression, data);
-		}
-		
-		public virtual object TrackedVisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
-			return base.VisitPropertyDeclaration(propertyDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
-			return base.VisitPropertyGetRegion(propertyGetRegion, data);
-		}
-		
-		public virtual object TrackedVisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
-			return base.VisitPropertySetRegion(propertySetRegion, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpression(QueryExpression queryExpression, object data) {
-			return base.VisitQueryExpression(queryExpression, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
-			return base.VisitQueryExpressionAggregateClause(queryExpressionAggregateClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
-			return base.VisitQueryExpressionDistinctClause(queryExpressionDistinctClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
-			return base.VisitQueryExpressionFromClause(queryExpressionFromClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
-			return base.VisitQueryExpressionGroupClause(queryExpressionGroupClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
-			return base.VisitQueryExpressionGroupJoinVBClause(queryExpressionGroupJoinVBClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
-			return base.VisitQueryExpressionGroupVBClause(queryExpressionGroupVBClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
-			return base.VisitQueryExpressionJoinClause(queryExpressionJoinClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
-			return base.VisitQueryExpressionJoinConditionVB(queryExpressionJoinConditionVB, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
-			return base.VisitQueryExpressionJoinVBClause(queryExpressionJoinVBClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
-			return base.VisitQueryExpressionLetClause(queryExpressionLetClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionLetVBClause(QueryExpressionLetVBClause queryExpressionLetVBClause, object data) {
-			return base.VisitQueryExpressionLetVBClause(queryExpressionLetVBClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
-			return base.VisitQueryExpressionOrderClause(queryExpressionOrderClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
-			return base.VisitQueryExpressionOrdering(queryExpressionOrdering, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
-			return base.VisitQueryExpressionPartitionVBClause(queryExpressionPartitionVBClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
-			return base.VisitQueryExpressionSelectClause(queryExpressionSelectClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
-			return base.VisitQueryExpressionSelectVBClause(queryExpressionSelectVBClause, data);
-		}
-		
-		public virtual object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
-			return base.VisitQueryExpressionWhereClause(queryExpressionWhereClause, data);
-		}
-		
-		public virtual object TrackedVisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
-			return base.VisitRaiseEventStatement(raiseEventStatement, data);
-		}
-		
-		public virtual object TrackedVisitReDimStatement(ReDimStatement reDimStatement, object data) {
-			return base.VisitReDimStatement(reDimStatement, data);
-		}
-		
-		public virtual object TrackedVisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
-			return base.VisitRemoveHandlerStatement(removeHandlerStatement, data);
-		}
-		
-		public virtual object TrackedVisitResumeStatement(ResumeStatement resumeStatement, object data) {
-			return base.VisitResumeStatement(resumeStatement, data);
-		}
-		
-		public virtual object TrackedVisitReturnStatement(ReturnStatement returnStatement, object data) {
-			return base.VisitReturnStatement(returnStatement, data);
-		}
-		
-		public virtual object TrackedVisitStopStatement(StopStatement stopStatement, object data) {
-			return base.VisitStopStatement(stopStatement, data);
-		}
-		
-		public virtual object TrackedVisitSwitchSection(SwitchSection switchSection, object data) {
-			return base.VisitSwitchSection(switchSection, data);
-		}
-		
-		public virtual object TrackedVisitSwitchStatement(SwitchStatement switchStatement, object data) {
-			return base.VisitSwitchStatement(switchStatement, data);
-		}
-		
-		public virtual object TrackedVisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
-			return base.VisitTemplateDefinition(templateDefinition, data);
-		}
-		
-		public virtual object TrackedVisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
-			return base.VisitThisReferenceExpression(thisReferenceExpression, data);
-		}
-		
-		public virtual object TrackedVisitThrowStatement(ThrowStatement throwStatement, object data) {
-			return base.VisitThrowStatement(throwStatement, data);
-		}
-		
-		public virtual object TrackedVisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
-			return base.VisitTryCatchStatement(tryCatchStatement, data);
-		}
-		
-		public virtual object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
-			return base.VisitTypeDeclaration(typeDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
-			return base.VisitTypeOfExpression(typeOfExpression, data);
-		}
-		
-		public virtual object TrackedVisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
-			return base.VisitTypeOfIsExpression(typeOfIsExpression, data);
-		}
-		
-		public virtual object TrackedVisitTypeReference(TypeReference typeReference, object data) {
-			return base.VisitTypeReference(typeReference, data);
-		}
-		
-		public virtual object TrackedVisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
-			return base.VisitTypeReferenceExpression(typeReferenceExpression, data);
-		}
-		
-		public virtual object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
-			return base.VisitUnaryOperatorExpression(unaryOperatorExpression, data);
-		}
-		
-		public virtual object TrackedVisitUsing(Using @using, object data) {
-			return base.VisitUsing(@using, data);
-		}
-		
-		public virtual object TrackedVisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
-			return base.VisitUsingDeclaration(usingDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitUsingStatement(UsingStatement usingStatement, object data) {
-			return base.VisitUsingStatement(usingStatement, data);
-		}
-		
-		public virtual object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
-			return base.VisitVariableDeclaration(variableDeclaration, data);
-		}
-		
-		public virtual object TrackedVisitWithStatement(WithStatement withStatement, object data) {
-			return base.VisitWithStatement(withStatement, data);
-		}
-		
-		public virtual object TrackedVisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
-			return base.VisitXmlAttributeExpression(xmlAttributeExpression, data);
-		}
-		
-		public virtual object TrackedVisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
-			return base.VisitXmlContentExpression(xmlContentExpression, data);
-		}
-		
-		public virtual object TrackedVisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
-			return base.VisitXmlDocumentExpression(xmlDocumentExpression, data);
-		}
-		
-		public virtual object TrackedVisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
-			return base.VisitXmlElementExpression(xmlElementExpression, data);
-		}
-		
-		public virtual object TrackedVisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
-			return base.VisitXmlEmbeddedExpression(xmlEmbeddedExpression, data);
-		}
-		
-		public virtual object TrackedVisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
-			return base.VisitXmlMemberAccessExpression(xmlMemberAccessExpression, data);
-		}
-	}
+//	public abstract class NodeTrackingAstVisitor : AbstractAstVisitor {
+//		
+//		protected virtual void BeginVisit(INode node) {
+//		}
+//		
+//		protected virtual void EndVisit(INode node) {
+//		}
+//		
+//		public sealed override object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
+//			this.BeginVisit(addHandlerStatement);
+//			object result = this.TrackedVisitAddHandlerStatement(addHandlerStatement, data);
+//			this.EndVisit(addHandlerStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
+//			this.BeginVisit(addressOfExpression);
+//			object result = this.TrackedVisitAddressOfExpression(addressOfExpression, data);
+//			this.EndVisit(addressOfExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
+//			this.BeginVisit(arrayCreateExpression);
+//			object result = this.TrackedVisitArrayCreateExpression(arrayCreateExpression, data);
+//			this.EndVisit(arrayCreateExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
+//			this.BeginVisit(assignmentExpression);
+//			object result = this.TrackedVisitAssignmentExpression(assignmentExpression, data);
+//			this.EndVisit(assignmentExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
+//			this.BeginVisit(attribute);
+//			object result = this.TrackedVisitAttribute(attribute, data);
+//			this.EndVisit(attribute);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitAttributeSection(AttributeSection attributeSection, object data) {
+//			this.BeginVisit(attributeSection);
+//			object result = this.TrackedVisitAttributeSection(attributeSection, data);
+//			this.EndVisit(attributeSection);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
+//			this.BeginVisit(baseReferenceExpression);
+//			object result = this.TrackedVisitBaseReferenceExpression(baseReferenceExpression, data);
+//			this.EndVisit(baseReferenceExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
+//			this.BeginVisit(binaryOperatorExpression);
+//			object result = this.TrackedVisitBinaryOperatorExpression(binaryOperatorExpression, data);
+//			this.EndVisit(binaryOperatorExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitBlockStatement(BlockStatement blockStatement, object data) {
+//			this.BeginVisit(blockStatement);
+//			object result = this.TrackedVisitBlockStatement(blockStatement, data);
+//			this.EndVisit(blockStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitCaseLabel(CaseLabel caseLabel, object data) {
+//			this.BeginVisit(caseLabel);
+//			object result = this.TrackedVisitCaseLabel(caseLabel, data);
+//			this.EndVisit(caseLabel);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitCastExpression(CastExpression castExpression, object data) {
+//			this.BeginVisit(castExpression);
+//			object result = this.TrackedVisitCastExpression(castExpression, data);
+//			this.EndVisit(castExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitCatchClause(CatchClause catchClause, object data) {
+//			this.BeginVisit(catchClause);
+//			object result = this.TrackedVisitCatchClause(catchClause, data);
+//			this.EndVisit(catchClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
+//			this.BeginVisit(classReferenceExpression);
+//			object result = this.TrackedVisitClassReferenceExpression(classReferenceExpression, data);
+//			this.EndVisit(classReferenceExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
+//			this.BeginVisit(collectionInitializerExpression);
+//			object result = this.TrackedVisitCollectionInitializerExpression(collectionInitializerExpression, data);
+//			this.EndVisit(collectionInitializerExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
+//			this.BeginVisit(collectionRangeVariable);
+//			object result = this.TrackedVisitCollectionRangeVariable(collectionRangeVariable, data);
+//			this.EndVisit(collectionRangeVariable);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
+//			this.BeginVisit(compilationUnit);
+//			object result = this.TrackedVisitCompilationUnit(compilationUnit, data);
+//			this.EndVisit(compilationUnit);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
+//			this.BeginVisit(conditionalExpression);
+//			object result = this.TrackedVisitConditionalExpression(conditionalExpression, data);
+//			this.EndVisit(conditionalExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
+//			this.BeginVisit(constructorDeclaration);
+//			object result = this.TrackedVisitConstructorDeclaration(constructorDeclaration, data);
+//			this.EndVisit(constructorDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
+//			this.BeginVisit(constructorInitializer);
+//			object result = this.TrackedVisitConstructorInitializer(constructorInitializer, data);
+//			this.EndVisit(constructorInitializer);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitContinueStatement(ContinueStatement continueStatement, object data) {
+//			this.BeginVisit(continueStatement);
+//			object result = this.TrackedVisitContinueStatement(continueStatement, data);
+//			this.EndVisit(continueStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
+//			this.BeginVisit(declareDeclaration);
+//			object result = this.TrackedVisitDeclareDeclaration(declareDeclaration, data);
+//			this.EndVisit(declareDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
+//			this.BeginVisit(defaultValueExpression);
+//			object result = this.TrackedVisitDefaultValueExpression(defaultValueExpression, data);
+//			this.EndVisit(defaultValueExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
+//			this.BeginVisit(delegateDeclaration);
+//			object result = this.TrackedVisitDelegateDeclaration(delegateDeclaration, data);
+//			this.EndVisit(delegateDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
+//			this.BeginVisit(directionExpression);
+//			object result = this.TrackedVisitDirectionExpression(directionExpression, data);
+//			this.EndVisit(directionExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
+//			this.BeginVisit(doLoopStatement);
+//			object result = this.TrackedVisitDoLoopStatement(doLoopStatement, data);
+//			this.EndVisit(doLoopStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
+//			this.BeginVisit(elseIfSection);
+//			object result = this.TrackedVisitElseIfSection(elseIfSection, data);
+//			this.EndVisit(elseIfSection);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitEndStatement(EndStatement endStatement, object data) {
+//			this.BeginVisit(endStatement);
+//			object result = this.TrackedVisitEndStatement(endStatement, data);
+//			this.EndVisit(endStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitEraseStatement(EraseStatement eraseStatement, object data) {
+//			this.BeginVisit(eraseStatement);
+//			object result = this.TrackedVisitEraseStatement(eraseStatement, data);
+//			this.EndVisit(eraseStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitErrorStatement(ErrorStatement errorStatement, object data) {
+//			this.BeginVisit(errorStatement);
+//			object result = this.TrackedVisitErrorStatement(errorStatement, data);
+//			this.EndVisit(errorStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
+//			this.BeginVisit(eventAddRegion);
+//			object result = this.TrackedVisitEventAddRegion(eventAddRegion, data);
+//			this.EndVisit(eventAddRegion);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
+//			this.BeginVisit(eventDeclaration);
+//			object result = this.TrackedVisitEventDeclaration(eventDeclaration, data);
+//			this.EndVisit(eventDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
+//			this.BeginVisit(eventRaiseRegion);
+//			object result = this.TrackedVisitEventRaiseRegion(eventRaiseRegion, data);
+//			this.EndVisit(eventRaiseRegion);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
+//			this.BeginVisit(eventRemoveRegion);
+//			object result = this.TrackedVisitEventRemoveRegion(eventRemoveRegion, data);
+//			this.EndVisit(eventRemoveRegion);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitExitStatement(ExitStatement exitStatement, object data) {
+//			this.BeginVisit(exitStatement);
+//			object result = this.TrackedVisitExitStatement(exitStatement, data);
+//			this.EndVisit(exitStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
+//			this.BeginVisit(expressionRangeVariable);
+//			object result = this.TrackedVisitExpressionRangeVariable(expressionRangeVariable, data);
+//			this.EndVisit(expressionRangeVariable);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
+//			this.BeginVisit(expressionStatement);
+//			object result = this.TrackedVisitExpressionStatement(expressionStatement, data);
+//			this.EndVisit(expressionStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
+//			this.BeginVisit(externAliasDirective);
+//			object result = this.TrackedVisitExternAliasDirective(externAliasDirective, data);
+//			this.EndVisit(externAliasDirective);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
+//			this.BeginVisit(fieldDeclaration);
+//			object result = this.TrackedVisitFieldDeclaration(fieldDeclaration, data);
+//			this.EndVisit(fieldDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
+//			this.BeginVisit(foreachStatement);
+//			object result = this.TrackedVisitForeachStatement(foreachStatement, data);
+//			this.EndVisit(foreachStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
+//			this.BeginVisit(forNextStatement);
+//			object result = this.TrackedVisitForNextStatement(forNextStatement, data);
+//			this.EndVisit(forNextStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitGotoStatement(GotoStatement gotoStatement, object data) {
+//			this.BeginVisit(gotoStatement);
+//			object result = this.TrackedVisitGotoStatement(gotoStatement, data);
+//			this.EndVisit(gotoStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitIdentifierExpression(SimpleNameExpression identifierExpression, object data) {
+//			this.BeginVisit(identifierExpression);
+//			object result = this.TrackedVisitIdentifierExpression(identifierExpression, data);
+//			this.EndVisit(identifierExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
+//			this.BeginVisit(ifElseStatement);
+//			object result = this.TrackedVisitIfElseStatement(ifElseStatement, data);
+//			this.EndVisit(ifElseStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
+//			this.BeginVisit(innerClassTypeReference);
+//			object result = this.TrackedVisitInnerClassTypeReference(innerClassTypeReference, data);
+//			this.EndVisit(innerClassTypeReference);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
+//			this.BeginVisit(interfaceImplementation);
+//			object result = this.TrackedVisitInterfaceImplementation(interfaceImplementation, data);
+//			this.EndVisit(interfaceImplementation);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
+//			this.BeginVisit(invocationExpression);
+//			object result = this.TrackedVisitInvocationExpression(invocationExpression, data);
+//			this.EndVisit(invocationExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitLabelStatement(LabelStatement labelStatement, object data) {
+//			this.BeginVisit(labelStatement);
+//			object result = this.TrackedVisitLabelStatement(labelStatement, data);
+//			this.EndVisit(labelStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
+//			this.BeginVisit(lambdaExpression);
+//			object result = this.TrackedVisitLambdaExpression(lambdaExpression, data);
+//			this.EndVisit(lambdaExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
+//			this.BeginVisit(localVariableDeclaration);
+//			object result = this.TrackedVisitLocalVariableDeclaration(localVariableDeclaration, data);
+//			this.EndVisit(localVariableDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitLockStatement(LockStatement lockStatement, object data) {
+//			this.BeginVisit(lockStatement);
+//			object result = this.TrackedVisitLockStatement(lockStatement, data);
+//			this.EndVisit(lockStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
+//			this.BeginVisit(memberInitializerExpression);
+//			object result = this.TrackedVisitMemberInitializerExpression(memberInitializerExpression, data);
+//			this.EndVisit(memberInitializerExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
+//			this.BeginVisit(memberReferenceExpression);
+//			object result = this.TrackedVisitMemberReferenceExpression(memberReferenceExpression, data);
+//			this.EndVisit(memberReferenceExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
+//			this.BeginVisit(methodDeclaration);
+//			object result = this.TrackedVisitMethodDeclaration(methodDeclaration, data);
+//			this.EndVisit(methodDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
+//			this.BeginVisit(namedArgumentExpression);
+//			object result = this.TrackedVisitNamedArgumentExpression(namedArgumentExpression, data);
+//			this.EndVisit(namedArgumentExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
+//			this.BeginVisit(namespaceDeclaration);
+//			object result = this.TrackedVisitNamespaceDeclaration(namespaceDeclaration, data);
+//			this.EndVisit(namespaceDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
+//			this.BeginVisit(objectCreateExpression);
+//			object result = this.TrackedVisitObjectCreateExpression(objectCreateExpression, data);
+//			this.EndVisit(objectCreateExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
+//			this.BeginVisit(onErrorStatement);
+//			object result = this.TrackedVisitOnErrorStatement(onErrorStatement, data);
+//			this.EndVisit(onErrorStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
+//			this.BeginVisit(operatorDeclaration);
+//			object result = this.TrackedVisitOperatorDeclaration(operatorDeclaration, data);
+//			this.EndVisit(operatorDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
+//			this.BeginVisit(optionDeclaration);
+//			object result = this.TrackedVisitOptionDeclaration(optionDeclaration, data);
+//			this.EndVisit(optionDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
+//			this.BeginVisit(parameterDeclarationExpression);
+//			object result = this.TrackedVisitParameterDeclarationExpression(parameterDeclarationExpression, data);
+//			this.EndVisit(parameterDeclarationExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
+//			this.BeginVisit(parenthesizedExpression);
+//			object result = this.TrackedVisitParenthesizedExpression(parenthesizedExpression, data);
+//			this.EndVisit(parenthesizedExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
+//			this.BeginVisit(primitiveExpression);
+//			object result = this.TrackedVisitPrimitiveExpression(primitiveExpression, data);
+//			this.EndVisit(primitiveExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
+//			this.BeginVisit(propertyDeclaration);
+//			object result = this.TrackedVisitPropertyDeclaration(propertyDeclaration, data);
+//			this.EndVisit(propertyDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
+//			this.BeginVisit(propertyGetRegion);
+//			object result = this.TrackedVisitPropertyGetRegion(propertyGetRegion, data);
+//			this.EndVisit(propertyGetRegion);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
+//			this.BeginVisit(propertySetRegion);
+//			object result = this.TrackedVisitPropertySetRegion(propertySetRegion, data);
+//			this.EndVisit(propertySetRegion);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpression(QueryExpression queryExpression, object data) {
+//			this.BeginVisit(queryExpression);
+//			object result = this.TrackedVisitQueryExpression(queryExpression, data);
+//			this.EndVisit(queryExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
+//			this.BeginVisit(queryExpressionAggregateClause);
+//			object result = this.TrackedVisitQueryExpressionAggregateClause(queryExpressionAggregateClause, data);
+//			this.EndVisit(queryExpressionAggregateClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
+//			this.BeginVisit(queryExpressionDistinctClause);
+//			object result = this.TrackedVisitQueryExpressionDistinctClause(queryExpressionDistinctClause, data);
+//			this.EndVisit(queryExpressionDistinctClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
+//			this.BeginVisit(queryExpressionFromClause);
+//			object result = this.TrackedVisitQueryExpressionFromClause(queryExpressionFromClause, data);
+//			this.EndVisit(queryExpressionFromClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
+//			this.BeginVisit(queryExpressionGroupClause);
+//			object result = this.TrackedVisitQueryExpressionGroupClause(queryExpressionGroupClause, data);
+//			this.EndVisit(queryExpressionGroupClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
+//			this.BeginVisit(queryExpressionGroupJoinVBClause);
+//			object result = this.TrackedVisitQueryExpressionGroupJoinVBClause(queryExpressionGroupJoinVBClause, data);
+//			this.EndVisit(queryExpressionGroupJoinVBClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
+//			this.BeginVisit(queryExpressionGroupVBClause);
+//			object result = this.TrackedVisitQueryExpressionGroupVBClause(queryExpressionGroupVBClause, data);
+//			this.EndVisit(queryExpressionGroupVBClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
+//			this.BeginVisit(queryExpressionJoinClause);
+//			object result = this.TrackedVisitQueryExpressionJoinClause(queryExpressionJoinClause, data);
+//			this.EndVisit(queryExpressionJoinClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
+//			this.BeginVisit(queryExpressionJoinConditionVB);
+//			object result = this.TrackedVisitQueryExpressionJoinConditionVB(queryExpressionJoinConditionVB, data);
+//			this.EndVisit(queryExpressionJoinConditionVB);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
+//			this.BeginVisit(queryExpressionJoinVBClause);
+//			object result = this.TrackedVisitQueryExpressionJoinVBClause(queryExpressionJoinVBClause, data);
+//			this.EndVisit(queryExpressionJoinVBClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
+//			this.BeginVisit(queryExpressionLetClause);
+//			object result = this.TrackedVisitQueryExpressionLetClause(queryExpressionLetClause, data);
+//			this.EndVisit(queryExpressionLetClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionLetVBClause(QueryExpressionLetClause queryExpressionLetVBClause, object data) {
+//			this.BeginVisit(queryExpressionLetVBClause);
+//			object result = this.TrackedVisitQueryExpressionLetVBClause(queryExpressionLetVBClause, data);
+//			this.EndVisit(queryExpressionLetVBClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
+//			this.BeginVisit(queryExpressionOrderClause);
+//			object result = this.TrackedVisitQueryExpressionOrderClause(queryExpressionOrderClause, data);
+//			this.EndVisit(queryExpressionOrderClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
+//			this.BeginVisit(queryExpressionOrdering);
+//			object result = this.TrackedVisitQueryExpressionOrdering(queryExpressionOrdering, data);
+//			this.EndVisit(queryExpressionOrdering);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
+//			this.BeginVisit(queryExpressionPartitionVBClause);
+//			object result = this.TrackedVisitQueryExpressionPartitionVBClause(queryExpressionPartitionVBClause, data);
+//			this.EndVisit(queryExpressionPartitionVBClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
+//			this.BeginVisit(queryExpressionSelectClause);
+//			object result = this.TrackedVisitQueryExpressionSelectClause(queryExpressionSelectClause, data);
+//			this.EndVisit(queryExpressionSelectClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
+//			this.BeginVisit(queryExpressionSelectVBClause);
+//			object result = this.TrackedVisitQueryExpressionSelectVBClause(queryExpressionSelectVBClause, data);
+//			this.EndVisit(queryExpressionSelectVBClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
+//			this.BeginVisit(queryExpressionWhereClause);
+//			object result = this.TrackedVisitQueryExpressionWhereClause(queryExpressionWhereClause, data);
+//			this.EndVisit(queryExpressionWhereClause);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
+//			this.BeginVisit(raiseEventStatement);
+//			object result = this.TrackedVisitRaiseEventStatement(raiseEventStatement, data);
+//			this.EndVisit(raiseEventStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
+//			this.BeginVisit(reDimStatement);
+//			object result = this.TrackedVisitReDimStatement(reDimStatement, data);
+//			this.EndVisit(reDimStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
+//			this.BeginVisit(removeHandlerStatement);
+//			object result = this.TrackedVisitRemoveHandlerStatement(removeHandlerStatement, data);
+//			this.EndVisit(removeHandlerStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
+//			this.BeginVisit(resumeStatement);
+//			object result = this.TrackedVisitResumeStatement(resumeStatement, data);
+//			this.EndVisit(resumeStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitReturnStatement(ReturnStatement returnStatement, object data) {
+//			this.BeginVisit(returnStatement);
+//			object result = this.TrackedVisitReturnStatement(returnStatement, data);
+//			this.EndVisit(returnStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitStopStatement(StopStatement stopStatement, object data) {
+//			this.BeginVisit(stopStatement);
+//			object result = this.TrackedVisitStopStatement(stopStatement, data);
+//			this.EndVisit(stopStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitSwitchSection(SwitchSection switchSection, object data) {
+//			this.BeginVisit(switchSection);
+//			object result = this.TrackedVisitSwitchSection(switchSection, data);
+//			this.EndVisit(switchSection);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
+//			this.BeginVisit(switchStatement);
+//			object result = this.TrackedVisitSwitchStatement(switchStatement, data);
+//			this.EndVisit(switchStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
+//			this.BeginVisit(templateDefinition);
+//			object result = this.TrackedVisitTemplateDefinition(templateDefinition, data);
+//			this.EndVisit(templateDefinition);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
+//			this.BeginVisit(thisReferenceExpression);
+//			object result = this.TrackedVisitThisReferenceExpression(thisReferenceExpression, data);
+//			this.EndVisit(thisReferenceExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitThrowStatement(ThrowStatement throwStatement, object data) {
+//			this.BeginVisit(throwStatement);
+//			object result = this.TrackedVisitThrowStatement(throwStatement, data);
+//			this.EndVisit(throwStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
+//			this.BeginVisit(tryCatchStatement);
+//			object result = this.TrackedVisitTryCatchStatement(tryCatchStatement, data);
+//			this.EndVisit(tryCatchStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
+//			this.BeginVisit(typeDeclaration);
+//			object result = this.TrackedVisitTypeDeclaration(typeDeclaration, data);
+//			this.EndVisit(typeDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
+//			this.BeginVisit(typeOfExpression);
+//			object result = this.TrackedVisitTypeOfExpression(typeOfExpression, data);
+//			this.EndVisit(typeOfExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
+//			this.BeginVisit(typeOfIsExpression);
+//			object result = this.TrackedVisitTypeOfIsExpression(typeOfIsExpression, data);
+//			this.EndVisit(typeOfIsExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTypeReference(TypeReference typeReference, object data) {
+//			this.BeginVisit(typeReference);
+//			object result = this.TrackedVisitTypeReference(typeReference, data);
+//			this.EndVisit(typeReference);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
+//			this.BeginVisit(typeReferenceExpression);
+//			object result = this.TrackedVisitTypeReferenceExpression(typeReferenceExpression, data);
+//			this.EndVisit(typeReferenceExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
+//			this.BeginVisit(unaryOperatorExpression);
+//			object result = this.TrackedVisitUnaryOperatorExpression(unaryOperatorExpression, data);
+//			this.EndVisit(unaryOperatorExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitUsing(ImportsClause @using, object data) {
+//			this.BeginVisit(@using);
+//			object result = this.TrackedVisitUsing(@using, data);
+//			this.EndVisit(@using);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitUsingDeclaration(ImportsStatement usingDeclaration, object data) {
+//			this.BeginVisit(usingDeclaration);
+//			object result = this.TrackedVisitUsingDeclaration(usingDeclaration, data);
+//			this.EndVisit(usingDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitUsingStatement(UsingStatement usingStatement, object data) {
+//			this.BeginVisit(usingStatement);
+//			object result = this.TrackedVisitUsingStatement(usingStatement, data);
+//			this.EndVisit(usingStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
+//			this.BeginVisit(variableDeclaration);
+//			object result = this.TrackedVisitVariableDeclaration(variableDeclaration, data);
+//			this.EndVisit(variableDeclaration);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitWithStatement(WithStatement withStatement, object data) {
+//			this.BeginVisit(withStatement);
+//			object result = this.TrackedVisitWithStatement(withStatement, data);
+//			this.EndVisit(withStatement);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
+//			this.BeginVisit(xmlAttributeExpression);
+//			object result = this.TrackedVisitXmlAttributeExpression(xmlAttributeExpression, data);
+//			this.EndVisit(xmlAttributeExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+//			this.BeginVisit(xmlContentExpression);
+//			object result = this.TrackedVisitXmlContentExpression(xmlContentExpression, data);
+//			this.EndVisit(xmlContentExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+//			this.BeginVisit(xmlDocumentExpression);
+//			object result = this.TrackedVisitXmlDocumentExpression(xmlDocumentExpression, data);
+//			this.EndVisit(xmlDocumentExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+//			this.BeginVisit(xmlElementExpression);
+//			object result = this.TrackedVisitXmlElementExpression(xmlElementExpression, data);
+//			this.EndVisit(xmlElementExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+//			this.BeginVisit(xmlEmbeddedExpression);
+//			object result = this.TrackedVisitXmlEmbeddedExpression(xmlEmbeddedExpression, data);
+//			this.EndVisit(xmlEmbeddedExpression);
+//			return result;
+//		}
+//		
+//		public sealed override object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
+//			this.BeginVisit(xmlMemberAccessExpression);
+//			object result = this.TrackedVisitXmlMemberAccessExpression(xmlMemberAccessExpression, data);
+//			this.EndVisit(xmlMemberAccessExpression);
+//			return result;
+//		}
+//		
+//		public virtual object TrackedVisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
+//			return base.VisitAddHandlerStatement(addHandlerStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
+//			return base.VisitAddressOfExpression(addressOfExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
+//			return base.VisitArrayCreateExpression(arrayCreateExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
+//			return base.VisitAssignmentExpression(assignmentExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
+//			return base.VisitAttribute(attribute, data);
+//		}
+//		
+//		public virtual object TrackedVisitAttributeSection(AttributeSection attributeSection, object data) {
+//			return base.VisitAttributeSection(attributeSection, data);
+//		}
+//		
+//		public virtual object TrackedVisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
+//			return base.VisitBaseReferenceExpression(baseReferenceExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
+//			return base.VisitBinaryOperatorExpression(binaryOperatorExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitBlockStatement(BlockStatement blockStatement, object data) {
+//			return base.VisitBlockStatement(blockStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitCaseLabel(CaseLabel caseLabel, object data) {
+//			return base.VisitCaseLabel(caseLabel, data);
+//		}
+//		
+//		public virtual object TrackedVisitCastExpression(CastExpression castExpression, object data) {
+//			return base.VisitCastExpression(castExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitCatchClause(CatchClause catchClause, object data) {
+//			return base.VisitCatchClause(catchClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
+//			return base.VisitClassReferenceExpression(classReferenceExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
+//			return base.VisitCollectionInitializerExpression(collectionInitializerExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
+//			return base.VisitCollectionRangeVariable(collectionRangeVariable, data);
+//		}
+//		
+//		public virtual object TrackedVisitCompilationUnit(CompilationUnit compilationUnit, object data) {
+//			return base.VisitCompilationUnit(compilationUnit, data);
+//		}
+//		
+//		public virtual object TrackedVisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
+//			return base.VisitConditionalExpression(conditionalExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
+//			return base.VisitConstructorDeclaration(constructorDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
+//			return base.VisitConstructorInitializer(constructorInitializer, data);
+//		}
+//		
+//		public virtual object TrackedVisitContinueStatement(ContinueStatement continueStatement, object data) {
+//			return base.VisitContinueStatement(continueStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
+//			return base.VisitDeclareDeclaration(declareDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
+//			return base.VisitDefaultValueExpression(defaultValueExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
+//			return base.VisitDelegateDeclaration(delegateDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitDirectionExpression(DirectionExpression directionExpression, object data) {
+//			return base.VisitDirectionExpression(directionExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
+//			return base.VisitDoLoopStatement(doLoopStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitElseIfSection(ElseIfSection elseIfSection, object data) {
+//			return base.VisitElseIfSection(elseIfSection, data);
+//		}
+//		
+//		public virtual object TrackedVisitEndStatement(EndStatement endStatement, object data) {
+//			return base.VisitEndStatement(endStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitEraseStatement(EraseStatement eraseStatement, object data) {
+//			return base.VisitEraseStatement(eraseStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitErrorStatement(ErrorStatement errorStatement, object data) {
+//			return base.VisitErrorStatement(errorStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
+//			return base.VisitEventAddRegion(eventAddRegion, data);
+//		}
+//		
+//		public virtual object TrackedVisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
+//			return base.VisitEventDeclaration(eventDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
+//			return base.VisitEventRaiseRegion(eventRaiseRegion, data);
+//		}
+//		
+//		public virtual object TrackedVisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
+//			return base.VisitEventRemoveRegion(eventRemoveRegion, data);
+//		}
+//		
+//		public virtual object TrackedVisitExitStatement(ExitStatement exitStatement, object data) {
+//			return base.VisitExitStatement(exitStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
+//			return base.VisitExpressionRangeVariable(expressionRangeVariable, data);
+//		}
+//		
+//		public virtual object TrackedVisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
+//			return base.VisitExpressionStatement(expressionStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
+//			return base.VisitExternAliasDirective(externAliasDirective, data);
+//		}
+//		
+//		public virtual object TrackedVisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
+//			return base.VisitFieldDeclaration(fieldDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitForeachStatement(ForeachStatement foreachStatement, object data) {
+//			return base.VisitForeachStatement(foreachStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitForNextStatement(ForNextStatement forNextStatement, object data) {
+//			return base.VisitForNextStatement(forNextStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitGotoStatement(GotoStatement gotoStatement, object data) {
+//			return base.VisitGotoStatement(gotoStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitIdentifierExpression(SimpleNameExpression identifierExpression, object data) {
+//			return base.VisitIdentifierExpression(identifierExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
+//			return base.VisitIfElseStatement(ifElseStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
+//			return base.VisitInnerClassTypeReference(innerClassTypeReference, data);
+//		}
+//		
+//		public virtual object TrackedVisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
+//			return base.VisitInterfaceImplementation(interfaceImplementation, data);
+//		}
+//		
+//		public virtual object TrackedVisitInvocationExpression(InvocationExpression invocationExpression, object data) {
+//			return base.VisitInvocationExpression(invocationExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitLabelStatement(LabelStatement labelStatement, object data) {
+//			return base.VisitLabelStatement(labelStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
+//			return base.VisitLambdaExpression(lambdaExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
+//			return base.VisitLocalVariableDeclaration(localVariableDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitLockStatement(LockStatement lockStatement, object data) {
+//			return base.VisitLockStatement(lockStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
+//			return base.VisitMemberInitializerExpression(memberInitializerExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
+//			return base.VisitMemberReferenceExpression(memberReferenceExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
+//			return base.VisitMethodDeclaration(methodDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
+//			return base.VisitNamedArgumentExpression(namedArgumentExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
+//			return base.VisitNamespaceDeclaration(namespaceDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
+//			return base.VisitObjectCreateExpression(objectCreateExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
+//			return base.VisitOnErrorStatement(onErrorStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
+//			return base.VisitOperatorDeclaration(operatorDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
+//			return base.VisitOptionDeclaration(optionDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
+//			return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
+//			return base.VisitParenthesizedExpression(parenthesizedExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
+//			return base.VisitPrimitiveExpression(primitiveExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
+//			return base.VisitPropertyDeclaration(propertyDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
+//			return base.VisitPropertyGetRegion(propertyGetRegion, data);
+//		}
+//		
+//		public virtual object TrackedVisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
+//			return base.VisitPropertySetRegion(propertySetRegion, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpression(QueryExpression queryExpression, object data) {
+//			return base.VisitQueryExpression(queryExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
+//			return base.VisitQueryExpressionAggregateClause(queryExpressionAggregateClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
+//			return base.VisitQueryExpressionDistinctClause(queryExpressionDistinctClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
+//			return base.VisitQueryExpressionFromClause(queryExpressionFromClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
+//			return base.VisitQueryExpressionGroupClause(queryExpressionGroupClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
+//			return base.VisitQueryExpressionGroupJoinVBClause(queryExpressionGroupJoinVBClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
+//			return base.VisitQueryExpressionGroupVBClause(queryExpressionGroupVBClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
+//			return base.VisitQueryExpressionJoinClause(queryExpressionJoinClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
+//			return base.VisitQueryExpressionJoinConditionVB(queryExpressionJoinConditionVB, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
+//			return base.VisitQueryExpressionJoinVBClause(queryExpressionJoinVBClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
+//			return base.VisitQueryExpressionLetClause(queryExpressionLetClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionLetVBClause(QueryExpressionLetClause queryExpressionLetVBClause, object data) {
+//			return base.VisitQueryExpressionLetVBClause(queryExpressionLetVBClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
+//			return base.VisitQueryExpressionOrderClause(queryExpressionOrderClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
+//			return base.VisitQueryExpressionOrdering(queryExpressionOrdering, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
+//			return base.VisitQueryExpressionPartitionVBClause(queryExpressionPartitionVBClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
+//			return base.VisitQueryExpressionSelectClause(queryExpressionSelectClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
+//			return base.VisitQueryExpressionSelectVBClause(queryExpressionSelectVBClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
+//			return base.VisitQueryExpressionWhereClause(queryExpressionWhereClause, data);
+//		}
+//		
+//		public virtual object TrackedVisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
+//			return base.VisitRaiseEventStatement(raiseEventStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitReDimStatement(ReDimStatement reDimStatement, object data) {
+//			return base.VisitReDimStatement(reDimStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
+//			return base.VisitRemoveHandlerStatement(removeHandlerStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitResumeStatement(ResumeStatement resumeStatement, object data) {
+//			return base.VisitResumeStatement(resumeStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitReturnStatement(ReturnStatement returnStatement, object data) {
+//			return base.VisitReturnStatement(returnStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitStopStatement(StopStatement stopStatement, object data) {
+//			return base.VisitStopStatement(stopStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitSwitchSection(SwitchSection switchSection, object data) {
+//			return base.VisitSwitchSection(switchSection, data);
+//		}
+//		
+//		public virtual object TrackedVisitSwitchStatement(SwitchStatement switchStatement, object data) {
+//			return base.VisitSwitchStatement(switchStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
+//			return base.VisitTemplateDefinition(templateDefinition, data);
+//		}
+//		
+//		public virtual object TrackedVisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
+//			return base.VisitThisReferenceExpression(thisReferenceExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitThrowStatement(ThrowStatement throwStatement, object data) {
+//			return base.VisitThrowStatement(throwStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
+//			return base.VisitTryCatchStatement(tryCatchStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
+//			return base.VisitTypeDeclaration(typeDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
+//			return base.VisitTypeOfExpression(typeOfExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
+//			return base.VisitTypeOfIsExpression(typeOfIsExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitTypeReference(TypeReference typeReference, object data) {
+//			return base.VisitTypeReference(typeReference, data);
+//		}
+//		
+//		public virtual object TrackedVisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
+//			return base.VisitTypeReferenceExpression(typeReferenceExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
+//			return base.VisitUnaryOperatorExpression(unaryOperatorExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitUsing(ImportsClause @using, object data) {
+//			return base.VisitUsing(@using, data);
+//		}
+//		
+//		public virtual object TrackedVisitUsingDeclaration(ImportsStatement usingDeclaration, object data) {
+//			return base.VisitUsingDeclaration(usingDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitUsingStatement(UsingStatement usingStatement, object data) {
+//			return base.VisitUsingStatement(usingStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
+//			return base.VisitVariableDeclaration(variableDeclaration, data);
+//		}
+//		
+//		public virtual object TrackedVisitWithStatement(WithStatement withStatement, object data) {
+//			return base.VisitWithStatement(withStatement, data);
+//		}
+//		
+//		public virtual object TrackedVisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
+//			return base.VisitXmlAttributeExpression(xmlAttributeExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
+//			return base.VisitXmlContentExpression(xmlContentExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
+//			return base.VisitXmlDocumentExpression(xmlDocumentExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
+//			return base.VisitXmlElementExpression(xmlElementExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
+//			return base.VisitXmlEmbeddedExpression(xmlEmbeddedExpression, data);
+//		}
+//		
+//		public virtual object TrackedVisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
+//			return base.VisitXmlMemberAccessExpression(xmlMemberAccessExpression, data);
+//		}
+//	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NotImplementedAstVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NotImplementedAstVisitor.cs
deleted file mode 100644
index c9d26a55e..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/NotImplementedAstVisitor.cs
+++ /dev/null
@@ -1,469 +0,0 @@
-//------------------------------------------------------------------------------
-// <auto-generated>
-//     This code was generated by a tool.
-//     Runtime Version:4.0.30319.1
-//
-//     Changes to this file may cause incorrect behavior and will be lost if
-//     the code is regenerated.
-// </auto-generated>
-//------------------------------------------------------------------------------
-
-namespace ICSharpCode.NRefactory.VB.Visitors {
-	using System;
-	using ICSharpCode.NRefactory.VB.Ast;
-	
-	
-	/// <summary>
-	/// IAstVisitor implementation that always throws NotImplementedExceptions.
-	/// </summary>
-	public class NotImplementedAstVisitor : IAstVisitor {
-		
-		public virtual object VisitAddHandlerStatement(AddHandlerStatement addHandlerStatement, object data) {
-			throw new global::System.NotImplementedException("AddHandlerStatement");
-		}
-		
-		public virtual object VisitAddressOfExpression(AddressOfExpression addressOfExpression, object data) {
-			throw new global::System.NotImplementedException("AddressOfExpression");
-		}
-		
-		public virtual object VisitArrayCreateExpression(ArrayCreateExpression arrayCreateExpression, object data) {
-			throw new global::System.NotImplementedException("ArrayCreateExpression");
-		}
-		
-		public virtual object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) {
-			throw new global::System.NotImplementedException("AssignmentExpression");
-		}
-		
-		public virtual object VisitAttribute(ICSharpCode.NRefactory.VB.Ast.Attribute attribute, object data) {
-			throw new global::System.NotImplementedException("Attribute");
-		}
-		
-		public virtual object VisitAttributeSection(AttributeSection attributeSection, object data) {
-			throw new global::System.NotImplementedException("AttributeSection");
-		}
-		
-		public virtual object VisitBaseReferenceExpression(BaseReferenceExpression baseReferenceExpression, object data) {
-			throw new global::System.NotImplementedException("BaseReferenceExpression");
-		}
-		
-		public virtual object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) {
-			throw new global::System.NotImplementedException("BinaryOperatorExpression");
-		}
-		
-		public virtual object VisitBlockStatement(BlockStatement blockStatement, object data) {
-			throw new global::System.NotImplementedException("BlockStatement");
-		}
-		
-		public virtual object VisitCaseLabel(CaseLabel caseLabel, object data) {
-			throw new global::System.NotImplementedException("CaseLabel");
-		}
-		
-		public virtual object VisitCastExpression(CastExpression castExpression, object data) {
-			throw new global::System.NotImplementedException("CastExpression");
-		}
-		
-		public virtual object VisitCatchClause(CatchClause catchClause, object data) {
-			throw new global::System.NotImplementedException("CatchClause");
-		}
-		
-		public virtual object VisitClassReferenceExpression(ClassReferenceExpression classReferenceExpression, object data) {
-			throw new global::System.NotImplementedException("ClassReferenceExpression");
-		}
-		
-		public virtual object VisitCollectionInitializerExpression(CollectionInitializerExpression collectionInitializerExpression, object data) {
-			throw new global::System.NotImplementedException("CollectionInitializerExpression");
-		}
-		
-		public virtual object VisitCollectionRangeVariable(CollectionRangeVariable collectionRangeVariable, object data) {
-			throw new global::System.NotImplementedException("CollectionRangeVariable");
-		}
-		
-		public virtual object VisitCompilationUnit(CompilationUnit compilationUnit, object data) {
-			throw new global::System.NotImplementedException("CompilationUnit");
-		}
-		
-		public virtual object VisitConditionalExpression(ConditionalExpression conditionalExpression, object data) {
-			throw new global::System.NotImplementedException("ConditionalExpression");
-		}
-		
-		public virtual object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data) {
-			throw new global::System.NotImplementedException("ConstructorDeclaration");
-		}
-		
-		public virtual object VisitConstructorInitializer(ConstructorInitializer constructorInitializer, object data) {
-			throw new global::System.NotImplementedException("ConstructorInitializer");
-		}
-		
-		public virtual object VisitContinueStatement(ContinueStatement continueStatement, object data) {
-			throw new global::System.NotImplementedException("ContinueStatement");
-		}
-		
-		public virtual object VisitDeclareDeclaration(DeclareDeclaration declareDeclaration, object data) {
-			throw new global::System.NotImplementedException("DeclareDeclaration");
-		}
-		
-		public virtual object VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data) {
-			throw new global::System.NotImplementedException("DefaultValueExpression");
-		}
-		
-		public virtual object VisitDelegateDeclaration(DelegateDeclaration delegateDeclaration, object data) {
-			throw new global::System.NotImplementedException("DelegateDeclaration");
-		}
-		
-		public virtual object VisitDirectionExpression(DirectionExpression directionExpression, object data) {
-			throw new global::System.NotImplementedException("DirectionExpression");
-		}
-		
-		public virtual object VisitDoLoopStatement(DoLoopStatement doLoopStatement, object data) {
-			throw new global::System.NotImplementedException("DoLoopStatement");
-		}
-		
-		public virtual object VisitElseIfSection(ElseIfSection elseIfSection, object data) {
-			throw new global::System.NotImplementedException("ElseIfSection");
-		}
-		
-		public virtual object VisitEndStatement(EndStatement endStatement, object data) {
-			throw new global::System.NotImplementedException("EndStatement");
-		}
-		
-		public virtual object VisitEraseStatement(EraseStatement eraseStatement, object data) {
-			throw new global::System.NotImplementedException("EraseStatement");
-		}
-		
-		public virtual object VisitErrorStatement(ErrorStatement errorStatement, object data) {
-			throw new global::System.NotImplementedException("ErrorStatement");
-		}
-		
-		public virtual object VisitEventAddRegion(EventAddRegion eventAddRegion, object data) {
-			throw new global::System.NotImplementedException("EventAddRegion");
-		}
-		
-		public virtual object VisitEventDeclaration(EventDeclaration eventDeclaration, object data) {
-			throw new global::System.NotImplementedException("EventDeclaration");
-		}
-		
-		public virtual object VisitEventRaiseRegion(EventRaiseRegion eventRaiseRegion, object data) {
-			throw new global::System.NotImplementedException("EventRaiseRegion");
-		}
-		
-		public virtual object VisitEventRemoveRegion(EventRemoveRegion eventRemoveRegion, object data) {
-			throw new global::System.NotImplementedException("EventRemoveRegion");
-		}
-		
-		public virtual object VisitExitStatement(ExitStatement exitStatement, object data) {
-			throw new global::System.NotImplementedException("ExitStatement");
-		}
-		
-		public virtual object VisitExpressionRangeVariable(ExpressionRangeVariable expressionRangeVariable, object data) {
-			throw new global::System.NotImplementedException("ExpressionRangeVariable");
-		}
-		
-		public virtual object VisitExpressionStatement(ExpressionStatement expressionStatement, object data) {
-			throw new global::System.NotImplementedException("ExpressionStatement");
-		}
-		
-		public virtual object VisitExternAliasDirective(ExternAliasDirective externAliasDirective, object data) {
-			throw new global::System.NotImplementedException("ExternAliasDirective");
-		}
-		
-		public virtual object VisitFieldDeclaration(FieldDeclaration fieldDeclaration, object data) {
-			throw new global::System.NotImplementedException("FieldDeclaration");
-		}
-		
-		public virtual object VisitForeachStatement(ForeachStatement foreachStatement, object data) {
-			throw new global::System.NotImplementedException("ForeachStatement");
-		}
-		
-		public virtual object VisitForNextStatement(ForNextStatement forNextStatement, object data) {
-			throw new global::System.NotImplementedException("ForNextStatement");
-		}
-		
-		public virtual object VisitGotoStatement(GotoStatement gotoStatement, object data) {
-			throw new global::System.NotImplementedException("GotoStatement");
-		}
-		
-		public virtual object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data) {
-			throw new global::System.NotImplementedException("IdentifierExpression");
-		}
-		
-		public virtual object VisitIfElseStatement(IfElseStatement ifElseStatement, object data) {
-			throw new global::System.NotImplementedException("IfElseStatement");
-		}
-		
-		public virtual object VisitInnerClassTypeReference(InnerClassTypeReference innerClassTypeReference, object data) {
-			throw new global::System.NotImplementedException("InnerClassTypeReference");
-		}
-		
-		public virtual object VisitInterfaceImplementation(InterfaceImplementation interfaceImplementation, object data) {
-			throw new global::System.NotImplementedException("InterfaceImplementation");
-		}
-		
-		public virtual object VisitInvocationExpression(InvocationExpression invocationExpression, object data) {
-			throw new global::System.NotImplementedException("InvocationExpression");
-		}
-		
-		public virtual object VisitLabelStatement(LabelStatement labelStatement, object data) {
-			throw new global::System.NotImplementedException("LabelStatement");
-		}
-		
-		public virtual object VisitLambdaExpression(LambdaExpression lambdaExpression, object data) {
-			throw new global::System.NotImplementedException("LambdaExpression");
-		}
-		
-		public virtual object VisitLocalVariableDeclaration(LocalVariableDeclaration localVariableDeclaration, object data) {
-			throw new global::System.NotImplementedException("LocalVariableDeclaration");
-		}
-		
-		public virtual object VisitLockStatement(LockStatement lockStatement, object data) {
-			throw new global::System.NotImplementedException("LockStatement");
-		}
-		
-		public virtual object VisitMemberInitializerExpression(MemberInitializerExpression memberInitializerExpression, object data) {
-			throw new global::System.NotImplementedException("MemberInitializerExpression");
-		}
-		
-		public virtual object VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data) {
-			throw new global::System.NotImplementedException("MemberReferenceExpression");
-		}
-		
-		public virtual object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data) {
-			throw new global::System.NotImplementedException("MethodDeclaration");
-		}
-		
-		public virtual object VisitNamedArgumentExpression(NamedArgumentExpression namedArgumentExpression, object data) {
-			throw new global::System.NotImplementedException("NamedArgumentExpression");
-		}
-		
-		public virtual object VisitNamespaceDeclaration(NamespaceDeclaration namespaceDeclaration, object data) {
-			throw new global::System.NotImplementedException("NamespaceDeclaration");
-		}
-		
-		public virtual object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data) {
-			throw new global::System.NotImplementedException("ObjectCreateExpression");
-		}
-		
-		public virtual object VisitOnErrorStatement(OnErrorStatement onErrorStatement, object data) {
-			throw new global::System.NotImplementedException("OnErrorStatement");
-		}
-		
-		public virtual object VisitOperatorDeclaration(OperatorDeclaration operatorDeclaration, object data) {
-			throw new global::System.NotImplementedException("OperatorDeclaration");
-		}
-		
-		public virtual object VisitOptionDeclaration(OptionDeclaration optionDeclaration, object data) {
-			throw new global::System.NotImplementedException("OptionDeclaration");
-		}
-		
-		public virtual object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data) {
-			throw new global::System.NotImplementedException("ParameterDeclarationExpression");
-		}
-		
-		public virtual object VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data) {
-			throw new global::System.NotImplementedException("ParenthesizedExpression");
-		}
-		
-		public virtual object VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data) {
-			throw new global::System.NotImplementedException("PrimitiveExpression");
-		}
-		
-		public virtual object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data) {
-			throw new global::System.NotImplementedException("PropertyDeclaration");
-		}
-		
-		public virtual object VisitPropertyGetRegion(PropertyGetRegion propertyGetRegion, object data) {
-			throw new global::System.NotImplementedException("PropertyGetRegion");
-		}
-		
-		public virtual object VisitPropertySetRegion(PropertySetRegion propertySetRegion, object data) {
-			throw new global::System.NotImplementedException("PropertySetRegion");
-		}
-		
-		public virtual object VisitQueryExpression(QueryExpression queryExpression, object data) {
-			throw new global::System.NotImplementedException("QueryExpression");
-		}
-		
-		public virtual object VisitQueryExpressionAggregateClause(QueryExpressionAggregateClause queryExpressionAggregateClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionAggregateClause");
-		}
-		
-		public virtual object VisitQueryExpressionDistinctClause(QueryExpressionDistinctClause queryExpressionDistinctClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionDistinctClause");
-		}
-		
-		public virtual object VisitQueryExpressionFromClause(QueryExpressionFromClause queryExpressionFromClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionFromClause");
-		}
-		
-		public virtual object VisitQueryExpressionGroupClause(QueryExpressionGroupClause queryExpressionGroupClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionGroupClause");
-		}
-		
-		public virtual object VisitQueryExpressionGroupJoinVBClause(QueryExpressionGroupJoinVBClause queryExpressionGroupJoinVBClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionGroupJoinVBClause");
-		}
-		
-		public virtual object VisitQueryExpressionGroupVBClause(QueryExpressionGroupVBClause queryExpressionGroupVBClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionGroupVBClause");
-		}
-		
-		public virtual object VisitQueryExpressionJoinClause(QueryExpressionJoinClause queryExpressionJoinClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionJoinClause");
-		}
-		
-		public virtual object VisitQueryExpressionJoinConditionVB(QueryExpressionJoinConditionVB queryExpressionJoinConditionVB, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionJoinConditionVB");
-		}
-		
-		public virtual object VisitQueryExpressionJoinVBClause(QueryExpressionJoinVBClause queryExpressionJoinVBClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionJoinVBClause");
-		}
-		
-		public virtual object VisitQueryExpressionLetClause(QueryExpressionLetClause queryExpressionLetClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionLetClause");
-		}
-		
-		public virtual object VisitQueryExpressionLetVBClause(QueryExpressionLetVBClause queryExpressionLetVBClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionLetVBClause");
-		}
-		
-		public virtual object VisitQueryExpressionOrderClause(QueryExpressionOrderClause queryExpressionOrderClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionOrderClause");
-		}
-		
-		public virtual object VisitQueryExpressionOrdering(QueryExpressionOrdering queryExpressionOrdering, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionOrdering");
-		}
-		
-		public virtual object VisitQueryExpressionPartitionVBClause(QueryExpressionPartitionVBClause queryExpressionPartitionVBClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionPartitionVBClause");
-		}
-		
-		public virtual object VisitQueryExpressionSelectClause(QueryExpressionSelectClause queryExpressionSelectClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionSelectClause");
-		}
-		
-		public virtual object VisitQueryExpressionSelectVBClause(QueryExpressionSelectVBClause queryExpressionSelectVBClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionSelectVBClause");
-		}
-		
-		public virtual object VisitQueryExpressionWhereClause(QueryExpressionWhereClause queryExpressionWhereClause, object data) {
-			throw new global::System.NotImplementedException("QueryExpressionWhereClause");
-		}
-		
-		public virtual object VisitRaiseEventStatement(RaiseEventStatement raiseEventStatement, object data) {
-			throw new global::System.NotImplementedException("RaiseEventStatement");
-		}
-		
-		public virtual object VisitReDimStatement(ReDimStatement reDimStatement, object data) {
-			throw new global::System.NotImplementedException("ReDimStatement");
-		}
-		
-		public virtual object VisitRemoveHandlerStatement(RemoveHandlerStatement removeHandlerStatement, object data) {
-			throw new global::System.NotImplementedException("RemoveHandlerStatement");
-		}
-		
-		public virtual object VisitResumeStatement(ResumeStatement resumeStatement, object data) {
-			throw new global::System.NotImplementedException("ResumeStatement");
-		}
-		
-		public virtual object VisitReturnStatement(ReturnStatement returnStatement, object data) {
-			throw new global::System.NotImplementedException("ReturnStatement");
-		}
-		
-		public virtual object VisitStopStatement(StopStatement stopStatement, object data) {
-			throw new global::System.NotImplementedException("StopStatement");
-		}
-		
-		public virtual object VisitSwitchSection(SwitchSection switchSection, object data) {
-			throw new global::System.NotImplementedException("SwitchSection");
-		}
-		
-		public virtual object VisitSwitchStatement(SwitchStatement switchStatement, object data) {
-			throw new global::System.NotImplementedException("SwitchStatement");
-		}
-		
-		public virtual object VisitTemplateDefinition(TemplateDefinition templateDefinition, object data) {
-			throw new global::System.NotImplementedException("TemplateDefinition");
-		}
-		
-		public virtual object VisitThisReferenceExpression(ThisReferenceExpression thisReferenceExpression, object data) {
-			throw new global::System.NotImplementedException("ThisReferenceExpression");
-		}
-		
-		public virtual object VisitThrowStatement(ThrowStatement throwStatement, object data) {
-			throw new global::System.NotImplementedException("ThrowStatement");
-		}
-		
-		public virtual object VisitTryCatchStatement(TryCatchStatement tryCatchStatement, object data) {
-			throw new global::System.NotImplementedException("TryCatchStatement");
-		}
-		
-		public virtual object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data) {
-			throw new global::System.NotImplementedException("TypeDeclaration");
-		}
-		
-		public virtual object VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data) {
-			throw new global::System.NotImplementedException("TypeOfExpression");
-		}
-		
-		public virtual object VisitTypeOfIsExpression(TypeOfIsExpression typeOfIsExpression, object data) {
-			throw new global::System.NotImplementedException("TypeOfIsExpression");
-		}
-		
-		public virtual object VisitTypeReference(TypeReference typeReference, object data) {
-			throw new global::System.NotImplementedException("TypeReference");
-		}
-		
-		public virtual object VisitTypeReferenceExpression(TypeReferenceExpression typeReferenceExpression, object data) {
-			throw new global::System.NotImplementedException("TypeReferenceExpression");
-		}
-		
-		public virtual object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) {
-			throw new global::System.NotImplementedException("UnaryOperatorExpression");
-		}
-		
-		public virtual object VisitUsing(Using @using, object data) {
-			throw new global::System.NotImplementedException("Using");
-		}
-		
-		public virtual object VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data) {
-			throw new global::System.NotImplementedException("UsingDeclaration");
-		}
-		
-		public virtual object VisitUsingStatement(UsingStatement usingStatement, object data) {
-			throw new global::System.NotImplementedException("UsingStatement");
-		}
-		
-		public virtual object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data) {
-			throw new global::System.NotImplementedException("VariableDeclaration");
-		}
-		
-		public virtual object VisitWithStatement(WithStatement withStatement, object data) {
-			throw new global::System.NotImplementedException("WithStatement");
-		}
-		
-		public virtual object VisitXmlAttributeExpression(XmlAttributeExpression xmlAttributeExpression, object data) {
-			throw new global::System.NotImplementedException("XmlAttributeExpression");
-		}
-		
-		public virtual object VisitXmlContentExpression(XmlContentExpression xmlContentExpression, object data) {
-			throw new global::System.NotImplementedException("XmlContentExpression");
-		}
-		
-		public virtual object VisitXmlDocumentExpression(XmlDocumentExpression xmlDocumentExpression, object data) {
-			throw new global::System.NotImplementedException("XmlDocumentExpression");
-		}
-		
-		public virtual object VisitXmlElementExpression(XmlElementExpression xmlElementExpression, object data) {
-			throw new global::System.NotImplementedException("XmlElementExpression");
-		}
-		
-		public virtual object VisitXmlEmbeddedExpression(XmlEmbeddedExpression xmlEmbeddedExpression, object data) {
-			throw new global::System.NotImplementedException("XmlEmbeddedExpression");
-		}
-		
-		public virtual object VisitXmlMemberAccessExpression(XmlMemberAccessExpression xmlMemberAccessExpression, object data) {
-			throw new global::System.NotImplementedException("XmlMemberAccessExpression");
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs
deleted file mode 100644
index 7bf15b034..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/PrefixFieldsVisitor.cs
+++ /dev/null
@@ -1,143 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	/// <summary>
-	/// Prefixes the names of the specified fields with the prefix and replaces the use.
-	/// </summary>
-	public class PrefixFieldsVisitor : AbstractAstVisitor
-	{
-		List<VariableDeclaration> fields;
-		List<string> curBlock = new List<string>();
-		Stack<List<string>> blocks = new Stack<List<string>>();
-		string prefix;
-		
-		public PrefixFieldsVisitor(List<VariableDeclaration> fields, string prefix)
-		{
-			this.fields = fields;
-			this.prefix = prefix;
-		}
-		
-		public void Run(INode typeDeclaration)
-		{
-			typeDeclaration.AcceptVisitor(this, null);
-			foreach (VariableDeclaration decl in fields) {
-				decl.Name = prefix + decl.Name;
-			}
-		}
-		
-		public override object VisitTypeDeclaration(TypeDeclaration typeDeclaration, object data)
-		{
-			Push();
-			object result = base.VisitTypeDeclaration(typeDeclaration, data);
-			Pop();
-			return result;
-		}
-		
-		public override object VisitBlockStatement(BlockStatement blockStatement, object data)
-		{
-			Push();
-			object result = base.VisitBlockStatement(blockStatement, data);
-			Pop();
-			return result;
-		}
-		
-		public override object VisitMethodDeclaration(MethodDeclaration methodDeclaration, object data)
-		{
-			Push();
-			object result = base.VisitMethodDeclaration(methodDeclaration, data);
-			Pop();
-			return result;
-		}
-		
-		public override object VisitPropertyDeclaration(PropertyDeclaration propertyDeclaration, object data)
-		{
-			Push();
-			object result = base.VisitPropertyDeclaration(propertyDeclaration, data);
-			Pop();
-			return result;
-		}
-		
-		public override object VisitConstructorDeclaration(ConstructorDeclaration constructorDeclaration, object data)
-		{
-			Push();
-			object result = base.VisitConstructorDeclaration(constructorDeclaration, data);
-			Pop();
-			return result;
-		}
-		
-		private void Push()
-		{
-			blocks.Push(curBlock);
-			curBlock = new List<string>();
-		}
-		
-		private void Pop()
-		{
-			curBlock = blocks.Pop();
-		}
-		
-		public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
-		{
-			// process local variables only
-			if (fields.Contains(variableDeclaration)) {
-				return null;
-			}
-			curBlock.Add(variableDeclaration.Name);
-			return base.VisitVariableDeclaration(variableDeclaration, data);
-		}
-		
-		public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)
-		{
-			curBlock.Add(parameterDeclarationExpression.ParameterName);
-			//print("add parameter ${parameterDeclarationExpression.ParameterName} to block")
-			return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data);
-		}
-		
-		public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
-		{
-			curBlock.Add(foreachStatement.VariableName);
-			return base.VisitForeachStatement(foreachStatement, data);
-		}
-		
-		public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
-		{
-			string name = identifierExpression.Identifier;
-			foreach (VariableDeclaration var in fields) {
-				if (var.Name == name && !IsLocal(name)) {
-					identifierExpression.Identifier = prefix + name;
-					break;
-				}
-			}
-			return base.VisitIdentifierExpression(identifierExpression, data);
-		}
-		
-		public override object VisitMemberReferenceExpression(MemberReferenceExpression fieldReferenceExpression, object data)
-		{
-			if (fieldReferenceExpression.TargetObject is ThisReferenceExpression) {
-				string name = fieldReferenceExpression.MemberName;
-				foreach (VariableDeclaration var in fields) {
-					if (var.Name == name) {
-						fieldReferenceExpression.MemberName = prefix + name;
-						break;
-					}
-				}
-			}
-			return base.VisitMemberReferenceExpression(fieldReferenceExpression, data);
-		}
-		
-		bool IsLocal(string name)
-		{
-			foreach (List<string> block in blocks) {
-				if (block.Contains(name))
-					return true;
-			}
-			return curBlock.Contains(name);
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs
deleted file mode 100644
index dc4ef2d33..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/RenameIdentifierVisitor.cs
+++ /dev/null
@@ -1,61 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	class RenameIdentifierVisitor : AbstractAstVisitor
-	{
-		protected StringComparer nameComparer;
-		protected string from, to;
-		
-		public RenameIdentifierVisitor(string from, string to, StringComparer nameComparer)
-		{
-			this.nameComparer = nameComparer;
-			this.from = from;
-			this.to = to;
-		}
-		
-		public override object VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
-		{
-			if (nameComparer.Equals(identifierExpression.Identifier, from)) {
-				identifierExpression.Identifier = to;
-			}
-			return base.VisitIdentifierExpression(identifierExpression, data);
-		}
-	}
-	
-	sealed class RenameLocalVariableVisitor : RenameIdentifierVisitor
-	{
-		public RenameLocalVariableVisitor(string from, string to, StringComparer nameComparer)
-			: base(from, to, nameComparer)
-		{
-		}
-		
-		public override object VisitVariableDeclaration(VariableDeclaration variableDeclaration, object data)
-		{
-			if (nameComparer.Equals(from, variableDeclaration.Name)) {
-				variableDeclaration.Name = to;
-			}
-			return base.VisitVariableDeclaration(variableDeclaration, data);
-		}
-		
-		public override object VisitParameterDeclarationExpression(ParameterDeclarationExpression parameterDeclarationExpression, object data)
-		{
-			if (nameComparer.Equals(from, parameterDeclarationExpression.ParameterName)) {
-				parameterDeclarationExpression.ParameterName = to;
-			}
-			return base.VisitParameterDeclarationExpression(parameterDeclarationExpression, data);
-		}
-		
-		public override object VisitForeachStatement(ForeachStatement foreachStatement, object data)
-		{
-			if (nameComparer.Equals(from, foreachStatement.VariableName)) {
-				foreachStatement.VariableName = to;
-			}
-			return base.VisitForeachStatement(foreachStatement, data);
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs
deleted file mode 100644
index 3122dedcd..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/SetParentVisitor.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.NRefactory.VB.Ast;
-using System.Collections.Generic;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	/// <summary>
-	/// Sets the parent property on all nodes in the tree.
-	/// </summary>
-	public class SetParentVisitor : NodeTrackingAstVisitor
-	{
-		Stack<INode> nodeStack = new Stack<INode>();
-		
-		public SetParentVisitor()
-		{
-			nodeStack.Push(null);
-		}
-		
-		protected override void BeginVisit(INode node)
-		{
-			node.Parent = nodeStack.Peek();
-			nodeStack.Push(node);
-		}
-		
-		protected override void EndVisit(INode node)
-		{
-			nodeStack.Pop();
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs b/NRefactory/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs
deleted file mode 100644
index 50aaca96f..000000000
--- a/NRefactory/ICSharpCode.NRefactory.VB/Visitors/SetRegionInclusionVisitor.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using ICSharpCode.NRefactory.VB.Ast;
-
-namespace ICSharpCode.NRefactory.VB.Visitors
-{
-	/// <summary>
-	/// Sets StartLocation and EndLocation (region) of every node to union of regions of its children.
-	/// Parsers don't do this by default:
-	/// e.g. "a.Foo()" is InvocationExpression, its region includes only the "()" and it has a child MemberReferenceExpression, with region ".Foo".
-	/// </summary>
-	public class SetRegionInclusionVisitor : NodeTrackingAstVisitor
-	{
-		Stack<INode> parentNodes = new Stack<INode>();
-		
-		public SetRegionInclusionVisitor()
-		{
-			parentNodes.Push(null);
-		}
-		
-		protected override void BeginVisit(INode node)
-		{
-			base.BeginVisit(node);
-			
-			// Only push nodes on the stack which have valid position information.
-			if (node != null &&
-			    node.StartLocation.X >= 1 && node.StartLocation.Y >= 1 &&
-			    node.EndLocation.X >= 1 && node.EndLocation.Y >= 1) {
-				
-				if (node is PropertyDeclaration) {
-					// PropertyDeclaration has correctly set BodyStart and BodyEnd by the parser,
-					// but it has no subnode "body", just 2 children GetRegion and SetRegion which don't span
-					// the whole (BodyStart, BodyEnd) region => We have to handle PropertyDeclaration as a special case.
-					node.EndLocation = ((PropertyDeclaration)node).BodyEnd;
-				}
-				
-				this.parentNodes.Push(node);
-			}
-		}
-		
-		protected override void EndVisit(INode node)
-		{
-			base.EndVisit(node);
-			
-			// Only remove those nodes which have actually been pushed before.
-			if (this.parentNodes.Count > 0 && INode.ReferenceEquals(this.parentNodes.Peek(), node)) {
-				// remove this node
-				this.parentNodes.Pop();
-				// fix region of parent
-				var parent = this.parentNodes.Peek();
-				if (parent == null)
-					return;
-				if (node.StartLocation < parent.StartLocation)
-					parent.StartLocation = node.StartLocation;
-				if (node.EndLocation > parent.EndLocation)
-					parent.EndLocation = node.EndLocation;
-			}
-			
-			// Block statement as a special case - we want it without the '{' and '}'
-			if (node is BlockStatement) {
-				var firstSatement = node.Children.FirstOrDefault();
-				if (firstSatement != null) {
-					node.StartLocation = firstSatement.StartLocation;
-					node.EndLocation = node.Children.Last().EndLocation;
-				}
-			}
-		}
-	}
-}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Identifier.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Identifier.cs
index 09639ab0b..70f1ddca4 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Identifier.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Identifier.cs
@@ -66,7 +66,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			}
 		}
 		
-		public bool IsQuoted {
+		/// <summary>
+		/// True if this is a verbatim identifier (starting with '@')
+		/// </summary>
+		public bool IsVerbatim {
 			get;
 			set;
 		}
@@ -80,7 +83,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		
 		public override AstLocation EndLocation {
 			get {
-				return new AstLocation (StartLocation.Line, StartLocation.Column + (Name ?? "").Length + (IsQuoted ? 1 : 0));
+				return new AstLocation (StartLocation.Line, StartLocation.Column + (Name ?? "").Length + (IsVerbatim ? 1 : 0));
 			}
 		}
 		
@@ -93,8 +96,8 @@ namespace ICSharpCode.NRefactory.CSharp
 		{
 			if (name == null)
 				throw new ArgumentNullException("name");
-			IsQuoted = name.StartsWith ("@");
-			this.Name = IsQuoted ? name.Substring (1) : name;
+			IsVerbatim = name.StartsWith ("@");
+			this.Name = IsVerbatim ? name.Substring (1) : name;
 			this.startLocation = location;
 		}
 		
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Role.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Role.cs
index 2d807a50a..675b344a7 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Role.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Ast/Role.cs
@@ -3,7 +3,7 @@
 
 using System;
 
-namespace ICSharpCode.NRefactory.CSharp
+namespace ICSharpCode.NRefactory
 {
 	/// <summary>
 	/// Represents the role a node plays within its parent.
@@ -15,14 +15,14 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// <summary>
 		/// Gets whether the specified node is valid in this role.
 		/// </summary>
-		public abstract bool IsValid(AstNode node);
+		public abstract bool IsValid(object node);
 	}
 	
 	/// <summary>
 	/// Represents the role a node plays within its parent.
 	/// All nodes with this role have type T.
 	/// </summary>
-	public sealed class Role<T> : Role where T : AstNode
+	public sealed class Role<T> : Role where T : class
 	{
 		readonly string name; // helps with debugging the AST
 		readonly T nullObject;
@@ -39,7 +39,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return nullObject; }
 		}
 		
-		public override bool IsValid(AstNode node)
+		public override bool IsValid(object node)
 		{
 			return node is T;
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/OutputVisitor/OutputVisitor.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/OutputVisitor/OutputVisitor.cs
index 7a7d56f6b..1c770b634 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/OutputVisitor/OutputVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/OutputVisitor/OutputVisitor.cs
@@ -1102,7 +1102,9 @@ namespace ICSharpCode.NRefactory.CSharp
 			queryFromClause.Type.AcceptVisitor(this, data);
 			Space();
 			WriteIdentifier(queryFromClause.Identifier);
+			Space();
 			WriteKeyword("in", QueryFromClause.InKeywordRole);
+			Space();
 			queryFromClause.Expression.AcceptVisitor(this, data);
 			return EndNode(queryFromClause);
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs
index 92d5e5ddd..17cb5e023 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/CSharpParser.cs
@@ -1,4 +1,4 @@
-// 
+// 
 // CSharpParser.cs
 //
 // Author:
@@ -23,7 +23,6 @@
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.
-
 using System;
 using System.Linq;
 using System.Collections.Generic;
@@ -39,7 +38,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		class ConversionVisitor : StructuralVisitor
 		{
 			CompilationUnit unit = new CompilationUnit ();
-			
+
 			public CompilationUnit Unit {
 				get {
 					return unit;
@@ -48,25 +47,25 @@ namespace ICSharpCode.NRefactory.CSharp
 					unit = value;
 				}
 			}
-			
+
 			public LocationsBag LocationsBag  {
 				get;
 				private set;
 			}
-			
+
 			public ConversionVisitor (LocationsBag locationsBag)
 			{
 				this.LocationsBag = locationsBag;
 			}
-			
+
 			public static AstLocation Convert (Mono.CSharp.Location loc)
 			{
 				return new AstLocation (loc.Row, loc.Column);
 			}
-			
+
 			#region Global
 			Stack<NamespaceDeclaration> namespaceStack = new Stack<NamespaceDeclaration> ();
-			
+
 			void AddTypeArguments (ATypeNameExpression texpr, AstType result)
 			{
 				if (texpr.TypeArguments == null || texpr.TypeArguments.Args == null)
@@ -75,7 +74,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					result.AddChild (ConvertToType (arg), AstType.Roles.TypeArgument);
 				}
 			}
-			
+
 			AstType ConvertToType (MemberName memberName)
 			{
 				AstType result;
@@ -92,7 +91,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				return result;
 			}
-				
+
 			AstType ConvertToType (Mono.CSharp.Expression typeName)
 			{
 				if (typeName is TypeExpression) {
@@ -102,9 +101,9 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				if (typeName is Mono.CSharp.QualifiedAliasMember) {
 					var qam = (Mono.CSharp.QualifiedAliasMember)typeName;
-					var memberType = new MemberType ();
+					var memberType = new MemberType (); 
 					if (qam.LeftExpression == null) {
-						memberType.Target = new SimpleType("global");
+						memberType.Target = new SimpleType ("global", Convert (qam.Location));
 					} else { 
 						memberType.Target = ConvertToType (qam.LeftExpression);
 					}
@@ -156,7 +155,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				System.Console.WriteLine (Environment.StackTrace);
 				return new SimpleType ("unknown");
 			}
-			
+
 			IEnumerable<Attribute> GetAttributes (Attributes optAttributes)
 			{
 				if (optAttributes == null || optAttributes.Attrs == null)
@@ -173,12 +172,12 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 					if (attr.NamedArguments != null) { 
 						foreach (NamedArgument na in attr.NamedArguments) {
-							NamedArgumentExpression newArg = new NamedArgumentExpression();
+							NamedArgumentExpression newArg = new NamedArgumentExpression ();
 							newArg.AddChild (new Identifier (na.Name, Convert (na.Location)), NamedArgumentExpression.Roles.Identifier);
 							
 							var loc = LocationsBag.GetLocations (na);
 							if (loc != null)
-								newArg.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), NamedArgumentExpression.Roles.Assign);
+								newArg.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), NamedArgumentExpression.Roles.Assign);
 							newArg.AddChild ((Expression)na.Expr.Accept (this), NamedArgumentExpression.Roles.Expression);
 							result.AddChild (newArg, Attribute.Roles.Argument);
 						}
@@ -186,7 +185,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					yield return result;
 				}
 			}
-			
+
 			AttributeSection ConvertAttributeSection (Attributes optAttributes)
 			{
 				if (optAttributes == null || optAttributes.Attrs == null)
@@ -206,7 +205,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					result.AddChild (new CSharpTokenNode (Convert (loc [1]), 1), AttributeSection.Roles.RBracket);
 				return result;
 			}
-			
+
 			public override void Visit (UsingsBag.Namespace nspace)
 			{
 				NamespaceDeclaration nDecl = null;
@@ -230,7 +229,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					namespaceStack.Pop ();
 				}
 			}
-			
+
 			void ConvertNamespaceName (MemberName memberName, NamespaceDeclaration namespaceDecl)
 			{
 				AstNode insertPos = null;
@@ -241,7 +240,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					memberName = memberName.Left;
 				}
 			}
-			
+
 			public override void Visit (UsingsBag.Using u)
 			{
 				UsingDeclaration ud = new UsingDeclaration ();
@@ -250,7 +249,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				ud.AddChild (new CSharpTokenNode (Convert (u.SemicolonLocation), 1), UsingDeclaration.Roles.Semicolon);
 				AddToNamespace (ud);
 			}
-			
+
 			public override void Visit (UsingsBag.AliasUsing u)
 			{
 				UsingAliasDeclaration ud = new UsingAliasDeclaration ();
@@ -276,28 +275,28 @@ namespace ICSharpCode.NRefactory.CSharp
 			{
 				if (memberName.Left != null) {
 					// left.name
-					var t = new MemberType();
+					var t = new MemberType ();
 					t.IsDoubleColon = memberName.IsDoubleColon;
 					t.AddChild (ConvertImport (memberName.Left), MemberType.TargetRole);
-					t.AddChild (new Identifier (memberName.Name, Convert(memberName.Location)), MemberType.Roles.Identifier);
+					t.AddChild (new Identifier (memberName.Name, Convert (memberName.Location)), MemberType.Roles.Identifier);
 					AddTypeArguments (t, (List<Location>)null, memberName.TypeArguments);
 					return t;
 				} else {
-					SimpleType t = new SimpleType();
-					t.AddChild (new Identifier (memberName.Name, Convert(memberName.Location)), SimpleType.Roles.Identifier);
+					SimpleType t = new SimpleType ();
+					t.AddChild (new Identifier (memberName.Name, Convert (memberName.Location)), SimpleType.Roles.Identifier);
 					AddTypeArguments (t, (List<Location>)null, memberName.TypeArguments);
 					return t;
 				}
 			}
-			
+
 			public override void Visit (MemberCore member)
 			{
 				Console.WriteLine ("Unknown member:");
 				Console.WriteLine (member.GetType () + "-> Member {0}", member.GetSignatureForError ());
 			}
-			
+
 			Stack<TypeDeclaration> typeStack = new Stack<TypeDeclaration> ();
-			
+
 			public override void Visit (Class c)
 			{
 				TypeDeclaration newType = new TypeDeclaration ();
@@ -307,15 +306,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetMemberLocation (c);
 				AddModifiers (newType, location);
 				if (location != null)
-					newType.AddChild (new CSharpTokenNode (Convert (location[0]), "class".Length), TypeDeclaration.Roles.Keyword);
+					newType.AddChild (new CSharpTokenNode (Convert (location [0]), "class".Length), TypeDeclaration.Roles.Keyword);
 				newType.AddChild (new Identifier (c.MemberName.Name, Convert (c.MemberName.Location)), AstNode.Roles.Identifier);
 				if (c.MemberName.TypeArguments != null)  {
 					var typeArgLocation = LocationsBag.GetLocations (c.MemberName);
 					if (typeArgLocation != null)
-						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), TypeDeclaration.Roles.LChevron);
+						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation [0]), 1), TypeDeclaration.Roles.LChevron);
 					AddTypeParameters (newType, typeArgLocation, c.MemberName.TypeArguments);
 					if (typeArgLocation != null)
-						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), TypeDeclaration.Roles.RChevron);
+						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation [1]), 1), TypeDeclaration.Roles.RChevron);
 					AddConstraints (newType, c);
 				}
 				if (c.TypeBaseExpressions != null) {
@@ -324,15 +323,15 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 				if (location != null && location.Count > 1)
-					newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [1]), 1), AstNode.Roles.LBrace);
 				typeStack.Push (newType);
 				base.Visit (c);
 				if (location != null && location.Count > 2)
-					newType.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AstNode.Roles.RBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [2]), 1), AstNode.Roles.RBrace);
 				typeStack.Pop ();
 				AddType (newType);
 			}
-			
+
 			public override void Visit (Struct s)
 			{
 				TypeDeclaration newType = new TypeDeclaration ();
@@ -341,15 +340,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetMemberLocation (s);
 				AddModifiers (newType, location);
 				if (location != null)
-					newType.AddChild (new CSharpTokenNode (Convert (location[0]), "struct".Length), TypeDeclaration.Roles.Keyword);
+					newType.AddChild (new CSharpTokenNode (Convert (location [0]), "struct".Length), TypeDeclaration.Roles.Keyword);
 				newType.AddChild (new Identifier (s.MemberName.Name, Convert (s.MemberName.Location)), AstNode.Roles.Identifier);
 				if (s.MemberName.TypeArguments != null)  {
 					var typeArgLocation = LocationsBag.GetLocations (s.MemberName);
 					if (typeArgLocation != null)
-						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), TypeDeclaration.Roles.LChevron);
+						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation [0]), 1), TypeDeclaration.Roles.LChevron);
 					AddTypeParameters (newType, typeArgLocation, s.MemberName.TypeArguments);
 					if (typeArgLocation != null)
-						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), TypeDeclaration.Roles.RChevron);
+						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation [1]), 1), TypeDeclaration.Roles.RChevron);
 					AddConstraints (newType, s);
 				}
 				
@@ -360,15 +359,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				
 				if (location != null && location.Count > 1)
-					newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [1]), 1), AstNode.Roles.LBrace);
 				typeStack.Push (newType);
 				base.Visit (s);
 				if (location != null && location.Count > 2)
-					newType.AddChild (new CSharpTokenNode  (Convert (location[2]), 1), AstNode.Roles.RBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [2]), 1), AstNode.Roles.RBrace);
 				typeStack.Pop ();
 				AddType (newType);
 			}
-			
+
 			public override void Visit (Interface i)
 			{
 				TypeDeclaration newType = new TypeDeclaration ();
@@ -377,15 +376,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetMemberLocation (i);
 				AddModifiers (newType, location);
 				if (location != null)
-					newType.AddChild (new CSharpTokenNode (Convert (location[0]), "interface".Length), TypeDeclaration.Roles.Keyword);
+					newType.AddChild (new CSharpTokenNode (Convert (location [0]), "interface".Length), TypeDeclaration.Roles.Keyword);
 				newType.AddChild (new Identifier (i.MemberName.Name, Convert (i.MemberName.Location)), AstNode.Roles.Identifier);
 				if (i.MemberName.TypeArguments != null)  {
 					var typeArgLocation = LocationsBag.GetLocations (i.MemberName);
 					if (typeArgLocation != null)
-						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
+						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation [0]), 1), MemberReferenceExpression.Roles.LChevron);
 					AddTypeParameters (newType, typeArgLocation, i.MemberName.TypeArguments);
 					if (typeArgLocation != null)
-						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
+						newType.AddChild (new CSharpTokenNode (Convert (typeArgLocation [1]), 1), MemberReferenceExpression.Roles.RChevron);
 					AddConstraints (newType, i);
 				}
 				if (i.TypeBaseExpressions != null) {
@@ -394,15 +393,15 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 				if (location != null && location.Count > 1)
-					newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [1]), 1), AstNode.Roles.LBrace);
 				typeStack.Push (newType);
 				base.Visit (i);
 				if (location != null && location.Count > 2)
-					newType.AddChild (new CSharpTokenNode  (Convert (location[2]), 1), AstNode.Roles.RBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [2]), 1), AstNode.Roles.RBrace);
 				typeStack.Pop ();
 				AddType (newType);
 			}
-			
+
 			public override void Visit (Mono.CSharp.Delegate d)
 			{
 				DelegateDeclaration newDelegate = new DelegateDeclaration ();
@@ -410,29 +409,29 @@ namespace ICSharpCode.NRefactory.CSharp
 				AddAttributeSection (newDelegate, d);
 				AddModifiers (newDelegate, location);
 				if (location != null)
-					newDelegate.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), TypeDeclaration.Roles.Keyword);
+					newDelegate.AddChild (new CSharpTokenNode (Convert (location [0]), "delegate".Length), TypeDeclaration.Roles.Keyword);
 				newDelegate.AddChild (ConvertToType (d.ReturnType), AstNode.Roles.Type);
 				newDelegate.AddChild (new Identifier (d.MemberName.Name, Convert (d.MemberName.Location)), AstNode.Roles.Identifier);
 				if (d.MemberName.TypeArguments != null)  {
 					var typeArgLocation = LocationsBag.GetLocations (d.MemberName);
 					if (typeArgLocation != null)
-						newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), TypeDeclaration.Roles.LChevron);
+						newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation [0]), 1), TypeDeclaration.Roles.LChevron);
 					AddTypeParameters (newDelegate, typeArgLocation, d.MemberName.TypeArguments);
 					if (typeArgLocation != null)
-						newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), TypeDeclaration.Roles.RChevron);
+						newDelegate.AddChild (new CSharpTokenNode (Convert (typeArgLocation [1]), 1), TypeDeclaration.Roles.RChevron);
 					AddConstraints (newDelegate, d);
 				}
 				if (location != null)
-					newDelegate.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DelegateDeclaration.Roles.LPar);
+					newDelegate.AddChild (new CSharpTokenNode (Convert (location [1]), 1), DelegateDeclaration.Roles.LPar);
 				AddParameter (newDelegate, d.Parameters);
 				
 				if (location != null) {
-					newDelegate.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DelegateDeclaration.Roles.RPar);
-					newDelegate.AddChild (new CSharpTokenNode (Convert (location[3]), 1), DelegateDeclaration.Roles.Semicolon);
+					newDelegate.AddChild (new CSharpTokenNode (Convert (location [2]), 1), DelegateDeclaration.Roles.RPar);
+					newDelegate.AddChild (new CSharpTokenNode (Convert (location [3]), 1), DelegateDeclaration.Roles.Semicolon);
 				}
 				AddType (newDelegate);
 			}
-			
+
 			void AddType (AttributedNode child)
 			{
 				if (typeStack.Count > 0) {
@@ -441,7 +440,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					AddToNamespace (child);
 				}
 			}
-			
+
 			void AddToNamespace (AstNode child)
 			{
 				if (namespaceStack.Count > 0) {
@@ -450,7 +449,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					unit.AddChild (child, CompilationUnit.MemberRole);
 				}
 			}
-			
+
 			public override void Visit (Mono.CSharp.Enum e)
 			{
 				TypeDeclaration newType = new TypeDeclaration ();
@@ -460,7 +459,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				AddModifiers (newType, location);
 				if (location != null)
-					newType.AddChild (new CSharpTokenNode (Convert (location[0]), "enum".Length), TypeDeclaration.Roles.Keyword);
+					newType.AddChild (new CSharpTokenNode (Convert (location [0]), "enum".Length), TypeDeclaration.Roles.Keyword);
 				newType.AddChild (new Identifier (e.MemberName.Name, Convert (e.MemberName.Location)), AstNode.Roles.Identifier);
 				
 				if (e.TypeBaseExpressions != null) {
@@ -470,15 +469,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 
 				if (location != null && location.Count > 1)
-					newType.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AstNode.Roles.LBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [1]), 1), AstNode.Roles.LBrace);
 				typeStack.Push (newType);
 				base.Visit (e);
 				if (location != null && location.Count > 2)
-					newType.AddChild (new CSharpTokenNode  (Convert (location[2]), 1), AstNode.Roles.RBrace);
+					newType.AddChild (new CSharpTokenNode (Convert (location [2]), 1), AstNode.Roles.RBrace);
 				typeStack.Pop ();
 				AddType (newType);
 			}
-			
+
 			public override void Visit (EnumMember em)
 			{
 				EnumMemberDeclaration newField = new EnumMemberDeclaration ();
@@ -491,6 +490,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 			}
+
 			#endregion
 			
 			#region Type members
@@ -540,7 +540,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 				if (location != null)
-					newField.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FieldDeclaration.Roles.Semicolon);
+					newField.AddChild (new CSharpTokenNode (Convert (location [1]), 1), FieldDeclaration.Roles.Semicolon);
 				typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 				
 			}
@@ -559,7 +559,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				if (f.Initializer != null) {
 					if (location != null)
-						variable.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FieldDeclaration.Roles.Assign);
+						variable.AddChild (new CSharpTokenNode (Convert (location [0]), 1), FieldDeclaration.Roles.Assign);
 					variable.AddChild ((Expression)f.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 				}
 				newField.AddChild (variable, FieldDeclaration.Roles.Variable);
@@ -567,7 +567,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					foreach (var decl in f.Declarators) {
 						var declLoc = LocationsBag.GetLocations (decl);
 						if (declLoc != null)
-							newField.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Comma);
+							newField.AddChild (new CSharpTokenNode (Convert (declLoc [0]), 1), FieldDeclaration.Roles.Comma);
 						
 						variable = new VariableInitializer ();
 						variable.AddChild (new Identifier (decl.Name.Value, Convert (decl.Name.Location)), VariableInitializer.Roles.Identifier);
@@ -579,11 +579,11 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 				if (location != null)
-					newField.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), FieldDeclaration.Roles.Semicolon);
+					newField.AddChild (new CSharpTokenNode (Convert (location [location.Count - 1]), 1), FieldDeclaration.Roles.Semicolon);
 
 				typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 			}
-			
+
 			public override void Visit (Const f)
 			{
 				var location = LocationsBag.GetMemberLocation (f);
@@ -592,7 +592,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				AddAttributeSection (newField, f);
 				AddModifiers (newField, location);
 				if (location != null)
-					newField.AddChild (new CSharpTokenNode (Convert (location[0]), "const".Length), FieldDeclaration.Roles.Keyword);
+					newField.AddChild (new CSharpTokenNode (Convert (location [0]), "const".Length), FieldDeclaration.Roles.Keyword);
 				newField.AddChild (ConvertToType (f.TypeName), FieldDeclaration.Roles.Type);
 				
 				VariableInitializer variable = new VariableInitializer ();
@@ -607,7 +607,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					foreach (var decl in f.Declarators) {
 						var declLoc = LocationsBag.GetLocations (decl);
 						if (declLoc != null)
-							newField.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Comma);
+							newField.AddChild (new CSharpTokenNode (Convert (declLoc [0]), 1), FieldDeclaration.Roles.Comma);
 						
 						variable = new VariableInitializer ();
 						variable.AddChild (new Identifier (decl.Name.Value, Convert (decl.Name.Location)), FieldDeclaration.Roles.Identifier);
@@ -619,13 +619,13 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 				if (location != null)
-					newField.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FieldDeclaration.Roles.Semicolon);
+					newField.AddChild (new CSharpTokenNode (Convert (location [1]), 1), FieldDeclaration.Roles.Semicolon);
 				
 				typeStack.Peek ().AddChild (newField, TypeDeclaration.MemberRole);
 
 				
 			}
-			
+
 			public override void Visit (Operator o)
 			{
 				OperatorDeclaration newOperator = new OperatorDeclaration ();
@@ -639,40 +639,40 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				if (o.OperatorType == Operator.OpType.Implicit) {
 					if (location != null) {
-						newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), "implicit".Length), OperatorDeclaration.OperatorTypeRole);
-						newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
+						newOperator.AddChild (new CSharpTokenNode (Convert (location [0]), "implicit".Length), OperatorDeclaration.OperatorTypeRole);
+						newOperator.AddChild (new CSharpTokenNode (Convert (location [1]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 					}
 				} else if (o.OperatorType == Operator.OpType.Explicit) {
 					if (location != null) {
-						newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), "explicit".Length), OperatorDeclaration.OperatorTypeRole);
-						newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
+						newOperator.AddChild (new CSharpTokenNode (Convert (location [0]), "explicit".Length), OperatorDeclaration.OperatorTypeRole);
+						newOperator.AddChild (new CSharpTokenNode (Convert (location [1]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 					}
 				} else {
 					if (location != null)
-						newOperator.AddChild (new CSharpTokenNode (Convert (location[0]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
+						newOperator.AddChild (new CSharpTokenNode (Convert (location [0]), "operator".Length), OperatorDeclaration.OperatorKeywordRole);
 					
 					int opLength = OperatorDeclaration.GetToken(newOperator.OperatorType).Length;
 					if (location != null)
-						newOperator.AddChild (new CSharpTokenNode (Convert (location[1]), opLength), OperatorDeclaration.OperatorTypeRole);
+						newOperator.AddChild (new CSharpTokenNode (Convert (location [1]), opLength), OperatorDeclaration.OperatorTypeRole);
 				}
 				if (location != null)
-					newOperator.AddChild (new CSharpTokenNode (Convert (location[2]), 1), OperatorDeclaration.Roles.LPar);
+					newOperator.AddChild (new CSharpTokenNode (Convert (location [2]), 1), OperatorDeclaration.Roles.LPar);
 				AddParameter (newOperator, o.ParameterInfo);
 				if (location != null)
-					newOperator.AddChild (new CSharpTokenNode (Convert (location[3]), 1), OperatorDeclaration.Roles.RPar);
+					newOperator.AddChild (new CSharpTokenNode (Convert (location [3]), 1), OperatorDeclaration.Roles.RPar);
 				
 				if (o.Block != null)
 					newOperator.AddChild ((BlockStatement)o.Block.Accept (this), OperatorDeclaration.Roles.Body);
 				
 				typeStack.Peek ().AddChild (newOperator, TypeDeclaration.MemberRole);
 			}
-			
+
 			public void AddAttributeSection (AttributedNode parent, Attributable a)
 			{
 				if (a.OptAttributes != null && a.OptAttributes.Attrs != null) 
 					parent.AddChild (ConvertAttributeSection (a.OptAttributes), AttributedNode.AttributeRole);
 			}
-			
+
 			public override void Visit (Indexer indexer)
 			{
 				IndexerDeclaration newIndexer = new IndexerDeclaration ();
@@ -685,13 +685,13 @@ namespace ICSharpCode.NRefactory.CSharp
 				newIndexer.AddChild (ConvertToType (indexer.TypeName), IndexerDeclaration.Roles.Type);
 				
 				if (location != null)
-					newIndexer.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IndexerDeclaration.Roles.LBracket);
-				AddParameter (newIndexer, indexer.Parameters);
+					newIndexer.AddChild (new CSharpTokenNode (Convert (location [0]), 1), IndexerDeclaration.Roles.LBracket);
+				AddParameter (newIndexer, indexer.ParameterInfo);
 				if (location != null)
-					newIndexer.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IndexerDeclaration.Roles.RBracket);
+					newIndexer.AddChild (new CSharpTokenNode (Convert (location [1]), 1), IndexerDeclaration.Roles.RBracket);
 				
 				if (location != null)
-					newIndexer.AddChild (new CSharpTokenNode (Convert (location[2]), 1), IndexerDeclaration.Roles.LBrace);
+					newIndexer.AddChild (new CSharpTokenNode (Convert (location [2]), 1), IndexerDeclaration.Roles.LBrace);
 				if (indexer.Get != null) {
 					Accessor getAccessor = new Accessor ();
 					var getLocation = LocationsBag.GetMemberLocation (indexer.Get);
@@ -703,7 +703,7 @@ namespace ICSharpCode.NRefactory.CSharp
 						getAccessor.AddChild ((BlockStatement)indexer.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
 					} else {
 						if (getLocation != null && getLocation.Count > 0)
-							newIndexer.AddChild (new CSharpTokenNode (Convert (getLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
+							newIndexer.AddChild (new CSharpTokenNode (Convert (getLocation [0]), 1), MethodDeclaration.Roles.Semicolon);
 					}
 					newIndexer.AddChild (getAccessor, PropertyDeclaration.GetterRole);
 				}
@@ -720,17 +720,17 @@ namespace ICSharpCode.NRefactory.CSharp
 						setAccessor.AddChild ((BlockStatement)indexer.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
 					} else {
 						if (setLocation != null && setLocation.Count > 0)
-							newIndexer.AddChild (new CSharpTokenNode (Convert (setLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
+							newIndexer.AddChild (new CSharpTokenNode (Convert (setLocation [0]), 1), MethodDeclaration.Roles.Semicolon);
 					}
 					newIndexer.AddChild (setAccessor, PropertyDeclaration.SetterRole);
 				}
 				
 				if (location != null)
-					newIndexer.AddChild (new CSharpTokenNode (Convert (location[3]), 1), IndexerDeclaration.Roles.RBrace);
+					newIndexer.AddChild (new CSharpTokenNode (Convert (location [3]), 1), IndexerDeclaration.Roles.RBrace);
 				
 				typeStack.Peek ().AddChild (newIndexer, TypeDeclaration.MemberRole);
 			}
-			
+
 			public override void Visit (Method m)
 			{
 				MethodDeclaration newMethod = new MethodDeclaration ();
@@ -747,19 +747,19 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (m.MemberName.TypeArguments != null)  {
 					var typeArgLocation = LocationsBag.GetLocations (m.MemberName);
 					if (typeArgLocation != null)
-						newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation[0]), 1), MemberReferenceExpression.Roles.LChevron);
+						newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation [0]), 1), MemberReferenceExpression.Roles.LChevron);
 					AddTypeParameters (newMethod, typeArgLocation, m.MemberName.TypeArguments);
 					if (typeArgLocation != null)
-						newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation[1]), 1), MemberReferenceExpression.Roles.RChevron);
+						newMethod.AddChild (new CSharpTokenNode (Convert (typeArgLocation [1]), 1), MemberReferenceExpression.Roles.RChevron);
 					AddConstraints (newMethod, m.GenericMethod);
 				}
 				
 				if (location != null)
-					newMethod.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
+					newMethod.AddChild (new CSharpTokenNode (Convert (location [0]), 1), MethodDeclaration.Roles.LPar);
 				AddParameter (newMethod, m.ParameterInfo);
 				
 				if (location != null)
-					newMethod.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
+					newMethod.AddChild (new CSharpTokenNode (Convert (location [1]), 1), MethodDeclaration.Roles.RPar);
 				if (m.Block != null) {
 					var bodyBlock = (BlockStatement)m.Block.Accept (this);
 //					if (m.Block is ToplevelBlock) {
@@ -770,10 +770,10 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				typeStack.Peek ().AddChild (newMethod, TypeDeclaration.MemberRole);
 			}
-			
+
 			static Dictionary<Mono.CSharp.Modifiers, ICSharpCode.NRefactory.CSharp.Modifiers> modifierTable = new Dictionary<Mono.CSharp.Modifiers, ICSharpCode.NRefactory.CSharp.Modifiers> ();
 			static string[] keywordTable;
-			
+
 			static ConversionVisitor ()
 			{
 				modifierTable [Mono.CSharp.Modifiers.NEW] = ICSharpCode.NRefactory.CSharp.Modifiers.New;
@@ -812,16 +812,16 @@ namespace ICSharpCode.NRefactory.CSharp
 				keywordTable [(int)BuiltinTypeSpec.Type.Decimal] = "decimal";
 				keywordTable [(int)BuiltinTypeSpec.Type.Char] = "char";
 			}
-			
+
 			void AddModifiers (AttributedNode parent, LocationsBag.MemberLocations location)
 			{
 				if (location == null || location.Modifiers == null)
 					return;
 				foreach (var modifier in location.Modifiers) {
-					parent.AddChild (new CSharpModifierToken (Convert (modifier.Item2), modifierTable[modifier.Item1]), AttributedNode.ModifierRole);
+					parent.AddChild (new CSharpModifierToken (Convert (modifier.Item2), modifierTable [modifier.Item1]), AttributedNode.ModifierRole);
 				}
 			}
-			
+
 			public override void Visit (Property p)
 			{
 				PropertyDeclaration newProperty = new PropertyDeclaration ();
@@ -835,7 +835,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				newProperty.AddChild (new Identifier (p.MemberName.Name, Convert (p.Location)), PropertyDeclaration.Roles.Identifier);
 				
 				if (location != null)
-					newProperty.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LBrace);
+					newProperty.AddChild (new CSharpTokenNode (Convert (location [0]), 1), MethodDeclaration.Roles.LBrace);
 				
 				if (p.Get != null) {
 					Accessor getAccessor = new Accessor ();
@@ -848,7 +848,7 @@ namespace ICSharpCode.NRefactory.CSharp
 						getAccessor.AddChild ((BlockStatement)p.Get.Block.Accept (this), MethodDeclaration.Roles.Body);
 					} else {
 						if (getLocation != null && getLocation.Count > 0)
-							newProperty.AddChild (new CSharpTokenNode (Convert (getLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
+							newProperty.AddChild (new CSharpTokenNode (Convert (getLocation [0]), 1), MethodDeclaration.Roles.Semicolon);
 					}
 					newProperty.AddChild (getAccessor, PropertyDeclaration.GetterRole);
 				}
@@ -864,16 +864,16 @@ namespace ICSharpCode.NRefactory.CSharp
 						setAccessor.AddChild ((BlockStatement)p.Set.Block.Accept (this), MethodDeclaration.Roles.Body);
 					} else {
 						if (setLocation != null && setLocation.Count > 0)
-							newProperty.AddChild (new CSharpTokenNode (Convert (setLocation[0]), 1), MethodDeclaration.Roles.Semicolon);
+							newProperty.AddChild (new CSharpTokenNode (Convert (setLocation [0]), 1), MethodDeclaration.Roles.Semicolon);
 					}
 					newProperty.AddChild (setAccessor, PropertyDeclaration.SetterRole);
 				}
 				if (location != null)
-					newProperty.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RBrace);
+					newProperty.AddChild (new CSharpTokenNode (Convert (location [1]), 1), MethodDeclaration.Roles.RBrace);
 				
 				typeStack.Peek ().AddChild (newProperty, TypeDeclaration.MemberRole);
 			}
-			
+
 			public override void Visit (Constructor c)
 			{
 				ConstructorDeclaration newConstructor = new ConstructorDeclaration ();
@@ -882,11 +882,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				AddModifiers (newConstructor, location);
 				newConstructor.AddChild (new Identifier (c.MemberName.Name, Convert (c.MemberName.Location)), AstNode.Roles.Identifier);
 				if (location != null)
-					newConstructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MethodDeclaration.Roles.LPar);
+					newConstructor.AddChild (new CSharpTokenNode (Convert (location [0]), 1), MethodDeclaration.Roles.LPar);
 				
 				AddParameter (newConstructor, c.ParameterInfo);
 				if (location != null)
-					newConstructor.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MethodDeclaration.Roles.RPar);
+					newConstructor.AddChild (new CSharpTokenNode (Convert (location [1]), 1), MethodDeclaration.Roles.RPar);
 				
 				if (c.Initializer != null) {
 					var initializer = new ConstructorInitializer ();
@@ -894,12 +894,12 @@ namespace ICSharpCode.NRefactory.CSharp
 					var initializerLocation = LocationsBag.GetLocations (c.Initializer);
 					
 					if (initializerLocation != null)
-						newConstructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ConstructorDeclaration.Roles.Colon);
+						newConstructor.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ConstructorDeclaration.Roles.Colon);
 					if (initializerLocation != null)
-						initializer.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ConstructorDeclaration.Roles.LPar);
+						initializer.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ConstructorDeclaration.Roles.LPar);
 					AddArguments (initializer, LocationsBag.GetLocations (c.Initializer.Arguments), c.Initializer.Arguments);
 					if (initializerLocation != null)
-						initializer.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ConstructorDeclaration.Roles.RPar);
+						initializer.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ConstructorDeclaration.Roles.RPar);
 					newConstructor.AddChild (initializer, ConstructorDeclaration.InitializerRole);
 				}
 				
@@ -908,7 +908,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				typeStack.Peek ().AddChild (newConstructor, TypeDeclaration.MemberRole);
 			}
-			
+
 			public override void Visit (Destructor d)
 			{
 				DestructorDeclaration newDestructor = new DestructorDeclaration ();
@@ -916,12 +916,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetMemberLocation (d);
 				AddModifiers (newDestructor, location);
 				if (location != null)
-					newDestructor.AddChild (new CSharpTokenNode (Convert (location[0]), 1), DestructorDeclaration.TildeRole);
+					newDestructor.AddChild (new CSharpTokenNode (Convert (location [0]), 1), DestructorDeclaration.TildeRole);
 				newDestructor.AddChild (new Identifier (d.MemberName.Name, Convert (d.MemberName.Location)), AstNode.Roles.Identifier);
 				
 				if (location != null) {
-					newDestructor.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DestructorDeclaration.Roles.LPar);
-					newDestructor.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DestructorDeclaration.Roles.RPar);
+					newDestructor.AddChild (new CSharpTokenNode (Convert (location [1]), 1), DestructorDeclaration.Roles.LPar);
+					newDestructor.AddChild (new CSharpTokenNode (Convert (location [2]), 1), DestructorDeclaration.Roles.RPar);
 				}
 				
 				if (d.Block != null)
@@ -929,7 +929,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				typeStack.Peek ().AddChild (newDestructor, TypeDeclaration.MemberRole);
 			}
-			
+
 			public override void Visit (EventField e)
 			{
 				EventDeclaration newEvent = new EventDeclaration ();
@@ -938,7 +938,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				AddModifiers (newEvent, location);
 				
 				if (location != null)
-					newEvent.AddChild (new CSharpTokenNode (Convert (location[0]), "event".Length), EventDeclaration.Roles.Keyword);
+					newEvent.AddChild (new CSharpTokenNode (Convert (location [0]), "event".Length), EventDeclaration.Roles.Keyword);
 				newEvent.AddChild (ConvertToType (e.TypeName), AstNode.Roles.Type);
 				
 				VariableInitializer variable = new VariableInitializer ();
@@ -946,7 +946,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				if (e.Initializer != null) {
 					if (location != null)
-						variable.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FieldDeclaration.Roles.Assign);
+						variable.AddChild (new CSharpTokenNode (Convert (location [0]), 1), FieldDeclaration.Roles.Assign);
 					variable.AddChild ((Expression)e.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 				}
 				newEvent.AddChild (variable, FieldDeclaration.Roles.Variable);
@@ -954,7 +954,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					foreach (var decl in e.Declarators) {
 						var declLoc = LocationsBag.GetLocations (decl);
 						if (declLoc != null)
-							newEvent.AddChild (new CSharpTokenNode (Convert (declLoc[0]), 1), FieldDeclaration.Roles.Comma);
+							newEvent.AddChild (new CSharpTokenNode (Convert (declLoc [0]), 1), FieldDeclaration.Roles.Comma);
 						
 						variable = new VariableInitializer ();
 						variable.AddChild (new Identifier (decl.Name.Value, Convert (decl.Name.Location)), VariableInitializer.Roles.Identifier);
@@ -968,11 +968,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				
 				if (location != null)
-					newEvent.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), EventDeclaration.Roles.Semicolon);
+					newEvent.AddChild (new CSharpTokenNode (Convert (location [1]), ";".Length), EventDeclaration.Roles.Semicolon);
 				
 				typeStack.Peek ().AddChild (newEvent, TypeDeclaration.MemberRole);
 			}
-			
+
 			public override void Visit (EventProperty ep)
 			{
 				CustomEventDeclaration newEvent = new CustomEventDeclaration ();
@@ -981,7 +981,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				AddModifiers (newEvent, location);
 				
 				if (location != null)
-					newEvent.AddChild (new CSharpTokenNode (Convert (location[0]), "event".Length), CustomEventDeclaration.Roles.Keyword);
+					newEvent.AddChild (new CSharpTokenNode (Convert (location [0]), "event".Length), CustomEventDeclaration.Roles.Keyword);
 				newEvent.AddChild (ConvertToType (ep.TypeName), CustomEventDeclaration.Roles.Type);
 				if (ep.MemberName.Left != null)
 					newEvent.AddChild (ConvertToType (ep.MemberName.Left), CustomEventDeclaration.PrivateImplementationTypeRole);
@@ -989,7 +989,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				newEvent.AddChild (new Identifier (ep.MemberName.Name, Convert (ep.Location)), CustomEventDeclaration.Roles.Identifier);
 
 				if (location != null && location.Count >= 2)
-					newEvent.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CustomEventDeclaration.Roles.LBrace);
+					newEvent.AddChild (new CSharpTokenNode (Convert (location [1]), 1), CustomEventDeclaration.Roles.LBrace);
 				
 				if (ep.Add != null) {
 					Accessor addAccessor = new Accessor ();
@@ -1014,11 +1014,11 @@ namespace ICSharpCode.NRefactory.CSharp
 					newEvent.AddChild (removeAccessor, CustomEventDeclaration.RemoveAccessorRole);
 				}
 				if (location != null && location.Count >= 3)
-					newEvent.AddChild (new CSharpTokenNode (Convert (location[2]), 1), CustomEventDeclaration.Roles.RBrace);
+					newEvent.AddChild (new CSharpTokenNode (Convert (location [2]), 1), CustomEventDeclaration.Roles.RBrace);
 				
 				typeStack.Peek ().AddChild (newEvent, TypeDeclaration.MemberRole);
 			}
-			
+
 			#endregion
 			
 			#region Statements
@@ -1027,7 +1027,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				Console.WriteLine ("unknown statement:" + stmt);
 				return null;
 			}
-			
+
 			public override object Visit (BlockVariableDeclaration blockVariableDeclaration)
 			{
 				var result = new VariableDeclarationStatement ();
@@ -1038,7 +1038,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				varInit.AddChild (new Identifier (blockVariableDeclaration.Variable.Name, Convert (blockVariableDeclaration.Variable.Location)), VariableInitializer.Roles.Identifier);
 				if (blockVariableDeclaration.Initializer != null) {
 					if (location != null)
-						varInit.AddChild (new CSharpTokenNode (Convert (location[0]), 1), VariableInitializer.Roles.Assign);
+						varInit.AddChild (new CSharpTokenNode (Convert (location [0]), 1), VariableInitializer.Roles.Assign);
 					varInit.AddChild ((Expression)blockVariableDeclaration.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 				}
 				
@@ -1061,10 +1061,10 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), VariableDeclarationStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [location.Count - 1]), 1), VariableDeclarationStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public override object Visit (BlockConstantDeclaration blockVariableDeclaration)
 			{
 				var result = new VariableDeclarationStatement ();
@@ -1079,7 +1079,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				varInit.AddChild (new Identifier (blockVariableDeclaration.Variable.Name, Convert (blockVariableDeclaration.Variable.Location)), VariableInitializer.Roles.Identifier);
 				if (blockVariableDeclaration.Initializer != null) {
 					if (location != null)
-						varInit.AddChild (new CSharpTokenNode (Convert (location[1]), 1), VariableInitializer.Roles.Assign);
+						varInit.AddChild (new CSharpTokenNode (Convert (location [1]), 1), VariableInitializer.Roles.Assign);
 					varInit.AddChild ((Expression)blockVariableDeclaration.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 				}
 				
@@ -1092,34 +1092,34 @@ namespace ICSharpCode.NRefactory.CSharp
 						init.AddChild (new Identifier (decl.Variable.Name, Convert (decl.Variable.Location)), VariableInitializer.Roles.Identifier);
 						if (decl.Initializer != null) {
 							if (loc != null)
-								init.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), VariableInitializer.Roles.Assign);
+								init.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), VariableInitializer.Roles.Assign);
 							init.AddChild ((Expression)decl.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 							if (loc != null && loc.Count > 1)
-								result.AddChild (new CSharpTokenNode (Convert (loc[1]), 1), VariableInitializer.Roles.Comma);
+								result.AddChild (new CSharpTokenNode (Convert (loc [1]), 1), VariableInitializer.Roles.Comma);
 						} else {
 							if (loc != null && loc.Count > 0)
-								result.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), VariableInitializer.Roles.Comma);
+								result.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), VariableInitializer.Roles.Comma);
 						}
 						result.AddChild (init, VariableDeclarationStatement.Roles.Variable);
 					}
 				}
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), 1), VariableDeclarationStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [location.Count - 1]), 1), VariableDeclarationStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.EmptyStatement emptyStatement)
 			{
 				var result = new EmptyStatement ();
 				result.Location = Convert (emptyStatement.loc);
 				return result;
 			}
-			
+
 			public override object Visit (EmptyExpressionStatement emptyExpressionStatement)
 			{
 				return new EmptyExpression (Convert (emptyExpressionStatement.Location));
 			}
-			
+
 			public override object Visit (If ifStatement)
 			{
 				var result = new IfElseStatement ();
@@ -1128,23 +1128,23 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (ifStatement.loc), "if".Length), IfElseStatement.IfKeywordRole);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IfElseStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), IfElseStatement.Roles.LPar);
 				result.AddChild ((Expression)ifStatement.Expr.Accept (this), IfElseStatement.Roles.Condition);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IfElseStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), IfElseStatement.Roles.RPar);
 				
 				if (ifStatement.TrueStatement != null)
 					result.AddChild ((Statement)ifStatement.TrueStatement.Accept (this), IfElseStatement.TrueRole);
 				
 				if (ifStatement.FalseStatement != null) {
 					if (location != null)
-						result.AddChild (new CSharpTokenNode (Convert (location[2]), "else".Length), IfElseStatement.ElseKeywordRole);
+						result.AddChild (new CSharpTokenNode (Convert (location [2]), "else".Length), IfElseStatement.ElseKeywordRole);
 					result.AddChild ((Statement)ifStatement.FalseStatement.Accept (this), IfElseStatement.FalseRole);
 				}
 				
 				return result;
 			}
-			
+
 			public override object Visit (Do doStatement)
 			{
 				var result = new DoWhileStatement ();
@@ -1152,18 +1152,18 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (doStatement.loc), "do".Length), DoWhileStatement.DoKeywordRole);
 				result.AddChild ((Statement)doStatement.EmbeddedStatement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "while".Length), DoWhileStatement.WhileKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "while".Length), DoWhileStatement.WhileKeywordRole);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), DoWhileStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), DoWhileStatement.Roles.LPar);
 				result.AddChild ((Expression)doStatement.expr.Accept (this), DoWhileStatement.Roles.Condition);
 				if (location != null) {
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), DoWhileStatement.Roles.RPar);
-					result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), DoWhileStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), 1), DoWhileStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [3]), 1), DoWhileStatement.Roles.Semicolon);
 				}
 				
 				return result;
 			}
-			
+
 			public override object Visit (While whileStatement)
 			{
 				var result = new WhileStatement ();
@@ -1171,15 +1171,16 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (whileStatement.loc), "while".Length), WhileStatement.WhileKeywordRole);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), WhileStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), WhileStatement.Roles.LPar);
+				if (whileStatement.expr != null)
 				result.AddChild ((Expression)whileStatement.expr.Accept (this), WhileStatement.Roles.Condition);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), WhileStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), WhileStatement.Roles.RPar);
+				if (whileStatement.Statement != null)
 				result.AddChild ((Statement)whileStatement.Statement.Accept (this), WhileStatement.Roles.EmbeddedStatement);
-				
 				return result;
 			}
-			
+
 			void AddStatementOrList (ForStatement forStatement, Mono.CSharp.Statement init, Role<Statement> role)
 			{
 				if (init == null)
@@ -1204,38 +1205,40 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (forStatement.loc), "for".Length), ForStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ForStatement.Roles.LPar);
 				
 				AddStatementOrList (result, forStatement.InitStatement, ForStatement.InitializerRole);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ForStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), ForStatement.Roles.Semicolon);
 				if (forStatement.Test != null)
 					result.AddChild ((Expression)forStatement.Test.Accept (this), ForStatement.Roles.Condition);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ForStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), 1), ForStatement.Roles.Semicolon);
 				
 				AddStatementOrList (result, forStatement.Increment, ForStatement.IteratorRole);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), ForStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [3]), 1), ForStatement.Roles.RPar);
 				
+				if (forStatement.Statement != null)
 				result.AddChild ((Statement)forStatement.Statement.Accept (this), ForStatement.Roles.EmbeddedStatement);
 				
 				return result;
 			}
-			
+
 			public override object Visit (StatementExpression statementExpression)
 			{
 				var result = new ExpressionStatement ();
 				object expr = statementExpression.Expr.Accept (this);
+				if (expr != null)
 				result.AddChild ((Expression)expr, ExpressionStatement.Roles.Expression);
 				var location = LocationsBag.GetLocations (statementExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ExpressionStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ExpressionStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public override object Visit (Return returnStatement)
 			{
 				var result = new ReturnStatement ();
@@ -1246,11 +1249,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				var location = LocationsBag.GetLocations (returnStatement);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ReturnStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ReturnStatement.Roles.Semicolon);
 				
 				return result;
 			}
-			
+
 			public override object Visit (Goto gotoStatement)
 			{
 				var result = new GotoStatement ();
@@ -1258,31 +1261,31 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (gotoStatement.loc), "goto".Length), GotoStatement.Roles.Keyword);
 				result.AddChild (new Identifier (gotoStatement.Target, Convert (gotoStatement.loc)), GotoStatement.Roles.Identifier);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), GotoStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), GotoStatement.Roles.Semicolon);
 				
 				return result;
 			}
-			
+
 			public override object Visit (LabeledStatement labeledStatement)
 			{
 				var result = new LabelStatement ();
 				result.AddChild (new Identifier (labeledStatement.Name, Convert (labeledStatement.loc)), LabelStatement.Roles.Identifier);
 				return result;
 			}
-			
+
 			public override object Visit (GotoDefault gotoDefault)
 			{
 				var result = new GotoDefaultStatement ();
 				result.AddChild (new CSharpTokenNode (Convert (gotoDefault.loc), "goto".Length), GotoDefaultStatement.Roles.Keyword);
 				var location = LocationsBag.GetLocations (gotoDefault);
 				if (location != null) {
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "default".Length), GotoDefaultStatement.DefaultKeywordRole);
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), GotoDefaultStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "default".Length), GotoDefaultStatement.DefaultKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), GotoDefaultStatement.Roles.Semicolon);
 				}
 				
 				return result;
 			}
-			
+
 			public override object Visit (GotoCase gotoCase)
 			{
 				var result = new GotoCaseStatement ();
@@ -1290,13 +1293,13 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				var location = LocationsBag.GetLocations (gotoCase);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "case".Length), GotoCaseStatement.CaseKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "case".Length), GotoCaseStatement.CaseKeywordRole);
 				result.AddChild ((Expression)gotoCase.Expr.Accept (this), GotoCaseStatement.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), GotoCaseStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), GotoCaseStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public override object Visit (Throw throwStatement)
 			{
 				var result = new ThrowStatement ();
@@ -1306,10 +1309,10 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (throwStatement.Expr != null)
 					result.AddChild ((Expression)throwStatement.Expr.Accept (this), ThrowStatement.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ThrowStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ThrowStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public override object Visit (Break breakStatement)
 			{
 				var result = new BreakStatement ();
@@ -1317,29 +1320,29 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (breakStatement.loc), "break".Length), BreakStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), BreakStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), BreakStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public override object Visit (Continue continueStatement)
 			{
 				var result = new ContinueStatement ();
 				var location = LocationsBag.GetLocations (continueStatement);
 				result.AddChild (new CSharpTokenNode (Convert (continueStatement.loc), "continue".Length), ContinueStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ContinueStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ContinueStatement.Roles.Semicolon);
 				return result;
 			}
-			
+
 			public static bool IsLower (Location left, Location right)
 			{
 				return left.Row < right.Row || left.Row == right.Row && left.Column < right.Column;
 			}
-			
+
 			public UsingStatement CreateUsingStatement (Block blockStatement)
 			{
 				var usingResult = new UsingStatement ();
-				Mono.CSharp.Statement cur = blockStatement.Statements[0];
+				Mono.CSharp.Statement cur = blockStatement.Statements [0];
 				if (cur is Using) {
 					Using u = (Using)cur;
 					usingResult.AddChild (new CSharpTokenNode (Convert (u.loc), "using".Length), UsingStatement.Roles.Keyword);
@@ -1349,7 +1352,7 @@ namespace ICSharpCode.NRefactory.CSharp
 						usingResult.AddChild (new Identifier (u.Variables.Variable.Name, Convert (u.Variables.Variable.Location)), UsingStatement.Roles.Identifier);
 						var loc = LocationsBag.GetLocations (u.Variables);
 						if (loc != null)
-							usingResult.AddChild (new CSharpTokenNode (Convert (loc[1]), 1), ContinueStatement.Roles.Assign);
+							usingResult.AddChild (new CSharpTokenNode (Convert (loc [1]), 1), ContinueStatement.Roles.Assign);
 						if (u.Variables.Initializer != null)
 							usingResult.AddChild ((AstNode)u.Variables.Initializer.Accept (this), UsingStatement.ResourceAcquisitionRole);
 						
@@ -1360,7 +1363,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				return usingResult;
 			}
-			
+
 			void AddBlockChildren (BlockStatement result, Block blockStatement, ref int curLocal)
 			{
 				foreach (Mono.CSharp.Statement stmt in blockStatement.Statements) {
@@ -1377,7 +1380,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					}
 				}
 			}
-			
+
 			public override object Visit (Block blockStatement)
 			{
 				if (blockStatement.IsCompilerGenerated && blockStatement.Statements.Any ()) {
@@ -1401,12 +1404,13 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetLocations (switchStatement);
 				result.AddChild (new CSharpTokenNode (Convert (switchStatement.loc), "switch".Length), SwitchStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), SwitchStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), SwitchStatement.Roles.LPar);
+				if (switchStatement.Expr != null)
 				result.AddChild ((Expression)switchStatement.Expr.Accept (this), SwitchStatement.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), SwitchStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), SwitchStatement.Roles.RPar);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), SwitchStatement.Roles.LBrace);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), 1), SwitchStatement.Roles.LBrace);
 				foreach (var section in switchStatement.Sections) {
 					var newSection = new SwitchSection ();
 					foreach (var caseLabel in section.Labels) {
@@ -1431,10 +1435,10 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[3]), 1), SwitchStatement.Roles.RBrace);
+					result.AddChild (new CSharpTokenNode (Convert (location [3]), 1), SwitchStatement.Roles.RBrace);
 				return result;
 			}
-			
+
 			public override object Visit (Lock lockStatement)
 			{
 				var result = new LockStatement ();
@@ -1442,16 +1446,16 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (lockStatement.loc), "lock".Length), LockStatement.Roles.Keyword);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), LockStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), LockStatement.Roles.LPar);
 				result.AddChild ((Expression)lockStatement.Expr.Accept (this), LockStatement.Roles.Expression);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), LockStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), LockStatement.Roles.RPar);
 				result.AddChild ((Statement)lockStatement.Statement.Accept (this), LockStatement.Roles.EmbeddedStatement);
 				
 				return result;
 			}
-			
+
 			public override object Visit (Unchecked uncheckedStatement)
 			{
 				var result = new UncheckedStatement ();
@@ -1459,8 +1463,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((BlockStatement)uncheckedStatement.Block.Accept (this), UncheckedStatement.Roles.Body);
 				return result;
 			}
-			
-			
+
 			public override object Visit (Checked checkedStatement)
 			{
 				var result = new CheckedStatement ();
@@ -1468,7 +1471,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((BlockStatement)checkedStatement.Block.Accept (this), CheckedStatement.Roles.Body);
 				return result;
 			}
-			
+
 			public override object Visit (Unsafe unsafeStatement)
 			{
 				var result = new UnsafeStatement ();
@@ -1476,7 +1479,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((BlockStatement)unsafeStatement.Block.Accept (this), UnsafeStatement.Roles.Body);
 				return result;
 			}
-			
+
 			public override object Visit (Fixed fixedStatement)
 			{
 				var result = new FixedStatement ();
@@ -1484,7 +1487,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (fixedStatement.loc), "fixed".Length), FixedStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), FixedStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), FixedStatement.Roles.LPar);
 				
 				if (fixedStatement.Variables != null) {
 					var blockVariableDeclaration = fixedStatement.Variables;
@@ -1494,7 +1497,7 @@ namespace ICSharpCode.NRefactory.CSharp
 					varInit.AddChild (new Identifier (blockVariableDeclaration.Variable.Name, Convert (blockVariableDeclaration.Variable.Location)), VariableInitializer.Roles.Identifier);
 					if (blockVariableDeclaration.Initializer != null) {
 						if (initLocation != null)
-							varInit.AddChild (new CSharpTokenNode (Convert (location[0]), 1), VariableInitializer.Roles.Assign);
+							varInit.AddChild (new CSharpTokenNode (Convert (location [0]), 1), VariableInitializer.Roles.Assign);
 						varInit.AddChild ((Expression)blockVariableDeclaration.Initializer.Accept (this), VariableInitializer.Roles.Expression);
 					}
 					
@@ -1519,11 +1522,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), FixedStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), FixedStatement.Roles.RPar);
 				result.AddChild ((Statement)fixedStatement.Statement.Accept (this), FixedStatement.Roles.EmbeddedStatement);
 				return result;
 			}
-			
+
 			public override object Visit (TryFinally tryFinallyStatement)
 			{
 				TryCatchStatement result;
@@ -1534,15 +1537,16 @@ namespace ICSharpCode.NRefactory.CSharp
 				} else {
 					result = new TryCatchStatement ();
 					result.AddChild (new CSharpTokenNode (Convert (tryFinallyStatement.loc), "try".Length), TryCatchStatement.TryKeywordRole);
+					if (tryFinallyStatement.Stmt != null)
 					result.AddChild ((BlockStatement)tryFinallyStatement.Stmt.Accept (this), TryCatchStatement.TryBlockRole);
 				}
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "finally".Length), TryCatchStatement.FinallyKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "finally".Length), TryCatchStatement.FinallyKeywordRole);
 				result.AddChild ((BlockStatement)tryFinallyStatement.Fini.Accept (this), TryCatchStatement.FinallyBlockRole);
 				
 				return result;
 			}
-			
+
 			CatchClause ConvertCatch (Catch ctch)
 			{
 				CatchClause result = new CatchClause ();
@@ -1550,25 +1554,26 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (ctch.loc), "catch".Length), CatchClause.Roles.Keyword);
 				if (ctch.TypeExpression != null) {
 					if (location != null)
-						result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CatchClause.Roles.LPar);
+						result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), CatchClause.Roles.LPar);
 					
 					result.AddChild (ConvertToType (ctch.TypeExpression), CatchClause.Roles.Type);
 					if (ctch.Variable != null && !string.IsNullOrEmpty (ctch.Variable.Name))
 						result.AddChild (new Identifier (ctch.Variable.Name, Convert (ctch.Variable.Location)), CatchClause.Roles.Identifier);
 					
 					if (location != null)
-						result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CatchClause.Roles.RPar);
+						result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), CatchClause.Roles.RPar);
 				}
 				
 				result.AddChild ((BlockStatement)ctch.Block.Accept (this), CatchClause.Roles.Body);
 				
 				return result;
 			}
-			
+
 			public override object Visit (TryCatch tryCatchStatement)
 			{
 				var result = new TryCatchStatement ();
 				result.AddChild (new CSharpTokenNode (Convert (tryCatchStatement.loc), "try".Length), TryCatchStatement.TryKeywordRole);
+				if (tryCatchStatement.Block != null)
 				result.AddChild ((BlockStatement)tryCatchStatement.Block.Accept (this), TryCatchStatement.TryBlockRole);
 				foreach (Catch ctch in tryCatchStatement.Specific) {
 					result.AddChild (ConvertCatch (ctch), TryCatchStatement.CatchClauseRole);
@@ -1578,7 +1583,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				return result;
 			}
-			
+
 			public override object Visit (Using usingStatement)
 			{
 				var result = new UsingStatement ();
@@ -1586,17 +1591,19 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (usingStatement.loc), "using".Length), UsingStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UsingStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), UsingStatement.Roles.LPar);
 				
+				if (usingStatement.Expression != null)
 				result.AddChild ((AstNode)usingStatement.Expression.Accept (this), UsingStatement.ResourceAcquisitionRole);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UsingStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), UsingStatement.Roles.RPar);
 				
+				if (usingStatement.Statement != null)
 				result.AddChild ((Statement)usingStatement.Statement.Accept (this), UsingStatement.Roles.EmbeddedStatement);
 				return result;
 			}
-			
+
 			public override object Visit (Foreach foreachStatement)
 			{
 				var result = new ForeachStatement ();
@@ -1605,7 +1612,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (foreachStatement.loc), "foreach".Length), ForeachStatement.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ForeachStatement.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ForeachStatement.Roles.LPar);
 				
 				if (foreachStatement.TypeExpr != null)
 					result.AddChild (ConvertToType (foreachStatement.TypeExpr), ForeachStatement.Roles.Type);
@@ -1613,18 +1620,19 @@ namespace ICSharpCode.NRefactory.CSharp
 					result.AddChild (new Identifier (foreachStatement.Variable.Name, Convert (foreachStatement.Variable.Location)), ForeachStatement.Roles.Identifier);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), "in".Length), ForeachStatement.Roles.InKeyword);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), "in".Length), ForeachStatement.Roles.InKeyword);
 				
 				if (foreachStatement.Expr != null)
 					result.AddChild ((Expression)foreachStatement.Expr.Accept (this), ForeachStatement.Roles.Expression);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), ForeachStatement.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), 1), ForeachStatement.Roles.RPar);
+				if (foreachStatement.Statement != null)
 				result.AddChild ((Statement)foreachStatement.Statement.Accept (this), ForeachStatement.Roles.EmbeddedStatement);
 				
 				return result;
 			}
-			
+
 			public override object Visit (Yield yieldStatement)
 			{
 				var result = new YieldStatement ();
@@ -1632,26 +1640,27 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				result.AddChild (new CSharpTokenNode (Convert (yieldStatement.loc), "yield".Length), YieldStatement.YieldKeywordRole);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "return".Length), YieldStatement.ReturnKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "return".Length), YieldStatement.ReturnKeywordRole);
 				if (yieldStatement.Expr != null)
 					result.AddChild ((Expression)yieldStatement.Expr.Accept (this), YieldStatement.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), YieldStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), ";".Length), YieldStatement.Roles.Semicolon);
 				
 				return result;
 			}
-			
+
 			public override object Visit (YieldBreak yieldBreakStatement)
 			{
 				var result = new YieldBreakStatement ();
 				var location = LocationsBag.GetLocations (yieldBreakStatement);
 				result.AddChild (new CSharpTokenNode (Convert (yieldBreakStatement.loc), "yield".Length), YieldBreakStatement.YieldKeywordRole);
 				if (location != null) {
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "break".Length), YieldBreakStatement.BreakKeywordRole);
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), ";".Length), YieldBreakStatement.Roles.Semicolon);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "break".Length), YieldBreakStatement.BreakKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), ";".Length), YieldBreakStatement.Roles.Semicolon);
 				}
 				return result;
 			}
+
 			#endregion
 			
 			#region Expression
@@ -1661,7 +1670,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				System.Console.WriteLine (Environment.StackTrace);
 				return null;
 			}
-			
+
 			public override object Visit (Mono.CSharp.DefaultParameterValueExpression defaultParameterValueExpression)
 			{
 				return defaultParameterValueExpression.Child.Accept (this);
@@ -1674,7 +1683,8 @@ namespace ICSharpCode.NRefactory.CSharp
 
 			public override object Visit (LocalVariableReference localVariableReference)
 			{
-				return new Identifier (localVariableReference.Name, Convert (localVariableReference.Location));;
+				return new Identifier (localVariableReference.Name, Convert (localVariableReference.Location));
+				;
 			}
 
 			public override object Visit (MemberAccess memberAccess)
@@ -1699,23 +1709,24 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (memberAccess.TypeArguments != null)  {
 					var location = LocationsBag.GetLocations (memberAccess);
 					if (location != null)
-						result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), MemberReferenceExpression.Roles.LChevron);
+						result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), MemberReferenceExpression.Roles.LChevron);
 					AddTypeArguments (result, location, memberAccess.TypeArguments);
 					if (location != null && location.Count > 1)
-						result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), MemberReferenceExpression.Roles.RChevron);
+						result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), MemberReferenceExpression.Roles.RChevron);
 				}
 				return result;
 			}
-			
+
 			public override object Visit (QualifiedAliasMember qualifiedAliasMember)
 			{
 				var result = new MemberType ();
-				result.Target = new SimpleType (qualifiedAliasMember.alias);
+				result.Target = new SimpleType (qualifiedAliasMember.alias, Convert (qualifiedAliasMember.Location));
 				result.IsDoubleColon = true;
-				result.AddChild (new Identifier (qualifiedAliasMember.Name, Convert (qualifiedAliasMember.Location)), MemberReferenceExpression.Roles.Identifier);
+				var location = LocationsBag.GetLocations (qualifiedAliasMember);
+				result.AddChild (new Identifier (qualifiedAliasMember.Name, location != null ? Convert (location [0]) : AstLocation.Empty), MemberReferenceExpression.Roles.Identifier);
 				return  new TypeReferenceExpression () { Type = result };
 			}
-			
+
 			public override object Visit (Constant constant)
 			{
 				if (constant.GetValue () == null) 
@@ -1731,32 +1742,31 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (simpleName.TypeArguments != null)  {
 					var location = LocationsBag.GetLocations (simpleName);
 					if (location != null)
-						result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), IdentifierExpression.Roles.LChevron);
+						result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), IdentifierExpression.Roles.LChevron);
 					AddTypeArguments (result, location, simpleName.TypeArguments);
 					if (location != null && location.Count > 1)
-						result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), IdentifierExpression.Roles.RChevron);
+						result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), IdentifierExpression.Roles.RChevron);
 				}
 				return result;
 			}
-			
+
 			public override object Visit (BooleanExpression booleanExpression)
 			{
 				return booleanExpression.Expr.Accept (this);
 			}
 
-			
 			public override object Visit (Mono.CSharp.ParenthesizedExpression parenthesizedExpression)
 			{
 				var result = new ParenthesizedExpression ();
 				var location = LocationsBag.GetLocations (parenthesizedExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ParenthesizedExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ParenthesizedExpression.Roles.LPar);
 				result.AddChild ((Expression)parenthesizedExpression.Expr.Accept (this), ParenthesizedExpression.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ParenthesizedExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), ParenthesizedExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (Unary unaryExpression)
 			{
 				var result = new UnaryOperatorExpression ();
@@ -1781,7 +1791,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((Expression)unaryExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
 				return result;
 			}
-			
+
 			public override object Visit (UnaryMutator unaryMutatorExpression)
 			{
 				var result = new UnaryOperatorExpression ();
@@ -1813,18 +1823,18 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				return result;
 			}
-			
+
 			public override object Visit (Indirection indirectionExpression)
 			{
 				var result = new UnaryOperatorExpression ();
 				result.Operator = UnaryOperatorType.Dereference;
 				var location = LocationsBag.GetLocations (indirectionExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 2), UnaryOperatorExpression.OperatorRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 2), UnaryOperatorExpression.OperatorRole);
 				result.AddChild ((Expression)indirectionExpression.Expr.Accept (this), UnaryOperatorExpression.Roles.Expression);
 				return result;
 			}
-			
+
 			public override object Visit (Is isExpression)
 			{
 				var result = new IsExpression ();
@@ -1833,7 +1843,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (ConvertToType (isExpression.ProbeType), IsExpression.Roles.Type);
 				return result;
 			}
-			
+
 			public override object Visit (As asExpression)
 			{
 				var result = new AsExpression ();
@@ -1842,7 +1852,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (ConvertToType (asExpression.ProbeType), AsExpression.Roles.Type);
 				return result;
 			}
-			
+
 			public override object Visit (Cast castExpression)
 			{
 				var result = new CastExpression ();
@@ -1852,12 +1862,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (castExpression.TargetType != null)
 					result.AddChild (ConvertToType (castExpression.TargetType), CastExpression.Roles.Type);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), CastExpression.Roles.RPar);
 				if (castExpression.Expr != null)
 					result.AddChild ((Expression)castExpression.Expr.Accept (this), CastExpression.Roles.Expression);
 				return result;
 			}
-			
+
 			public override object Visit (ComposedCast composedCast)
 			{
 				var result = new ComposedType ();
@@ -1882,20 +1892,20 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.DefaultValueExpression defaultValueExpression)
 			{
 				var result = new DefaultValueExpression ();
 				result.AddChild (new CSharpTokenNode (Convert (defaultValueExpression.Location), "default".Length), CastExpression.Roles.Keyword);
 				var location = LocationsBag.GetLocations (defaultValueExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), CastExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), CastExpression.Roles.LPar);
 				result.AddChild (ConvertToType (defaultValueExpression.Expr), CastExpression.Roles.Type);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), CastExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), CastExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (Binary binaryExpression)
 			{
 				var result = new BinaryOperatorExpression ();
@@ -1970,7 +1980,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((Expression)binaryExpression.Right.Accept (this), BinaryOperatorExpression.RightRole);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Nullable.NullCoalescingOperator nullCoalescingOperator)
 			{
 				var result = new BinaryOperatorExpression ();
@@ -1980,7 +1990,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((Expression)nullCoalescingOperator.Right.Accept (this), BinaryOperatorExpression.RightRole);
 				return result;
 			}
-			
+
 			public override object Visit (Conditional conditionalExpression)
 			{
 				var result = new ConditionalExpression ();
@@ -1991,11 +2001,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (conditionalExpression.Location), 1), ConditionalExpression.QuestionMarkRole);
 				result.AddChild ((Expression)conditionalExpression.TrueExpr.Accept (this), ConditionalExpression.TrueRole);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ConditionalExpression.ColonRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ConditionalExpression.ColonRole);
 				result.AddChild ((Expression)conditionalExpression.FalseExpr.Accept (this), ConditionalExpression.FalseRole);
 				return result;
 			}
-			
+
 			void AddParameter (AstNode parent, Mono.CSharp.AParametersCollection parameters)
 			{
 				if (parameters == null)
@@ -2045,54 +2055,54 @@ namespace ICSharpCode.NRefactory.CSharp
 					parent.AddChild (parameterDeclarationExpression, InvocationExpression.Roles.Parameter);
 				}
 			}
-			
+
 			void AddTypeParameters (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
 			{
 				if (typeArguments == null || typeArguments.IsEmpty)
 					return;
 				for (int i = 0; i < typeArguments.Count; i++) {
 					if (location != null && i > 0 && i - 1 < location.Count)
-						parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
-					var arg = (TypeParameterName)typeArguments.Args[i];
+						parent.AddChild (new CSharpTokenNode (Convert (location [i - 1]), 1), InvocationExpression.Roles.Comma);
+					var arg = (TypeParameterName)typeArguments.Args [i];
 					if (arg == null)
 						continue;
-					TypeParameterDeclaration tp = new TypeParameterDeclaration();
+					TypeParameterDeclaration tp = new TypeParameterDeclaration ();
 					// TODO: attributes
 					if (arg.Variance != Variance.None)
-						throw new NotImplementedException(); // TODO: variance
+						throw new NotImplementedException (); // TODO: variance
 					tp.AddChild (new Identifier (arg.Name, Convert (arg.Location)), InvocationExpression.Roles.Identifier);
 					parent.AddChild (tp, InvocationExpression.Roles.TypeParameter);
 				}
 			}
-			
+
 			void AddTypeArguments (AstNode parent, LocationsBag.MemberLocations location, Mono.CSharp.TypeArguments typeArguments)
 			{
 				if (typeArguments == null || typeArguments.IsEmpty)
 					return;
 				for (int i = 0; i < typeArguments.Count; i++) {
 					if (location != null && i > 0 && i - 1 < location.Count)
-						parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
-					var arg = typeArguments.Args[i];
+						parent.AddChild (new CSharpTokenNode (Convert (location [i - 1]), 1), InvocationExpression.Roles.Comma);
+					var arg = typeArguments.Args [i];
 					if (arg == null)
 						continue;
 					parent.AddChild (ConvertToType (arg), InvocationExpression.Roles.TypeArgument);
 				}
 			}
-			
+
 			void AddTypeArguments (AstNode parent, List<Location> location, Mono.CSharp.TypeArguments typeArguments)
 			{
 				if (typeArguments == null || typeArguments.IsEmpty)
 					return;
 				for (int i = 0; i < typeArguments.Count; i++) {
 					if (location != null && i > 0 && i - 1 < location.Count)
-						parent.AddChild (new CSharpTokenNode (Convert (location[i - 1]), 1), InvocationExpression.Roles.Comma);
-					var arg = typeArguments.Args[i];
+						parent.AddChild (new CSharpTokenNode (Convert (location [i - 1]), 1), InvocationExpression.Roles.Comma);
+					var arg = typeArguments.Args [i];
 					if (arg == null)
 						continue;
 					parent.AddChild (ConvertToType (arg), InvocationExpression.Roles.TypeArgument);
 				}
 			}
-			
+
 			void AddConstraints (AstNode parent, DeclSpace d)
 			{
 				if (d == null || d.Constraints == null)
@@ -2111,24 +2121,24 @@ namespace ICSharpCode.NRefactory.CSharp
 					parent.AddChild (constraint, AstNode.Roles.Constraint);
 				}
 			}
-			
+
 			Expression ConvertArgument (Argument arg)
 			{
 				if (arg is NamedArgument) {
 					var na = (NamedArgument)arg;
-					NamedArgumentExpression newArg = new NamedArgumentExpression();
+					NamedArgumentExpression newArg = new NamedArgumentExpression ();
 					newArg.AddChild (new Identifier (na.Name, Convert (na.Location)), NamedArgumentExpression.Roles.Identifier);
 					
 					var loc = LocationsBag.GetLocations (na);
 					if (loc != null)
-						newArg.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), NamedArgumentExpression.Roles.Assign);
+						newArg.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), NamedArgumentExpression.Roles.Assign);
 					
 					if (arg.ArgType == Argument.AType.Out || arg.ArgType == Argument.AType.Ref) {
 						DirectionExpression direction = new DirectionExpression ();
 						direction.FieldDirection = arg.ArgType == Argument.AType.Out ? FieldDirection.Out : FieldDirection.Ref;
 						var argLocation = LocationsBag.GetLocations (arg);
 						if (argLocation != null)
-							direction.AddChild (new CSharpTokenNode (Convert (argLocation[0]), "123".Length), InvocationExpression.Roles.Keyword);
+							direction.AddChild (new CSharpTokenNode (Convert (argLocation [0]), "123".Length), InvocationExpression.Roles.Keyword);
 						direction.AddChild ((Expression)arg.Expr.Accept (this), InvocationExpression.Roles.Expression);
 						newArg.AddChild (direction, NamedArgumentExpression.Roles.Expression);
 					} else {
@@ -2142,14 +2152,14 @@ namespace ICSharpCode.NRefactory.CSharp
 					direction.FieldDirection = arg.ArgType == Argument.AType.Out ? FieldDirection.Out : FieldDirection.Ref;
 					var argLocation = LocationsBag.GetLocations (arg);
 					if (argLocation != null)
-						direction.AddChild (new CSharpTokenNode (Convert (argLocation[0]), "123".Length), InvocationExpression.Roles.Keyword);
+						direction.AddChild (new CSharpTokenNode (Convert (argLocation [0]), "123".Length), InvocationExpression.Roles.Keyword);
 					direction.AddChild ((Expression)arg.Expr.Accept (this), InvocationExpression.Roles.Expression);
 					return direction;
 				}
 				
 				return (Expression)arg.Expr.Accept (this);
 			}
-			
+
 			void AddArguments (AstNode parent, object location, Mono.CSharp.Arguments args)
 			{
 				if (args == null)
@@ -2158,31 +2168,31 @@ namespace ICSharpCode.NRefactory.CSharp
 				var commaLocations = LocationsBag.GetLocations (args);
 				
 				for (int i = 0; i < args.Count; i++) {
-					parent.AddChild (ConvertArgument (args[i]), InvocationExpression.Roles.Argument);
+					parent.AddChild (ConvertArgument (args [i]), InvocationExpression.Roles.Argument);
 					if (commaLocations != null && i > 0) {
 						int idx = commaLocations.Count - i;
 						if (idx >= 0)
-							parent.AddChild (new CSharpTokenNode (Convert (commaLocations[idx]), 1), InvocationExpression.Roles.Comma);
+							parent.AddChild (new CSharpTokenNode (Convert (commaLocations [idx]), 1), InvocationExpression.Roles.Comma);
 					}
 				}
 				if (commaLocations != null && commaLocations.Count > args.Count)
-					parent.AddChild (new CSharpTokenNode (Convert (commaLocations[0]), 1), InvocationExpression.Roles.Comma);
+					parent.AddChild (new CSharpTokenNode (Convert (commaLocations [0]), 1), InvocationExpression.Roles.Comma);
 			}
-			
+
 			public override object Visit (Invocation invocationExpression)
 			{
 				var result = new InvocationExpression ();
 				var location = LocationsBag.GetLocations (invocationExpression);
 				result.AddChild ((Expression)invocationExpression.Expression.Accept (this), InvocationExpression.Roles.TargetExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), InvocationExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), InvocationExpression.Roles.LPar);
 				AddArguments (result, location, invocationExpression.Arguments);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), InvocationExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), InvocationExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (New newExpression)
 			{
 				var result = new ObjectCreateExpression ();
@@ -2193,15 +2203,15 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (newExpression.TypeRequested != null)
 					result.AddChild (ConvertToType (newExpression.TypeRequested), ObjectCreateExpression.Roles.Type);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ObjectCreateExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ObjectCreateExpression.Roles.LPar);
 				AddArguments (result, location, newExpression.Arguments);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ObjectCreateExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), ObjectCreateExpression.Roles.RPar);
 				
 				return result;
 			}
-			
+
 			public override object Visit (NewAnonymousType newAnonymousType)
 			{
 				var result = new AnonymousTypeCreateExpression ();
@@ -2213,15 +2223,14 @@ namespace ICSharpCode.NRefactory.CSharp
 					} else {
 						var namedArgument = new NamedArgumentExpression ();
 						namedArgument.AddChild (new Identifier (par.Name, Convert (par.Location)), AnonymousTypeCreateExpression.Roles.Identifier);
-						namedArgument.AddChild (new CSharpTokenNode (Convert (location[0]), 1), AnonymousTypeCreateExpression.Roles.Assign);
+						namedArgument.AddChild (new CSharpTokenNode (Convert (location [0]), 1), AnonymousTypeCreateExpression.Roles.Assign);
 						namedArgument.AddChild ((Expression)par.Expr.Accept (this), AnonymousTypeCreateExpression.Roles.Expression);
 						result.AddChild (namedArgument, AnonymousTypeCreateExpression.Roles.Expression);
 					}
 				}
 				return result;
 			}
-			
-			
+
 			public override object Visit (NewInitialize newInitializeExpression)
 			{
 				var result = new ObjectCreateExpression ();
@@ -2232,15 +2241,14 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				var location = LocationsBag.GetLocations (newInitializeExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ObjectCreateExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ObjectCreateExpression.Roles.LPar);
 				AddArguments (result, location, newInitializeExpression.Arguments);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ObjectCreateExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), ObjectCreateExpression.Roles.RPar);
 				
 				return result;
 			}
-			
-			
+
 			public override object Visit (ArrayCreation arrayCreationExpression)
 			{
 				var result = new ArrayCreateExpression ();
@@ -2249,11 +2257,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (arrayCreationExpression.NewType != null)
 					result.AddChild (ConvertToType (arrayCreationExpression.NewType), ArrayCreateExpression.Roles.Type);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), ArrayCreateExpression.Roles.LBracket);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), ArrayCreateExpression.Roles.LBracket);
 				if (arrayCreationExpression.Arguments != null) {
 					var commaLocations = LocationsBag.GetLocations (arrayCreationExpression.Arguments);
-					for (int i = 0 ;i < arrayCreationExpression.Arguments.Count; i++) {
-						result.AddChild ((Expression)arrayCreationExpression.Arguments[i].Accept (this), ArrayCreateExpression.Roles.Argument);
+					for (int i = 0; i < arrayCreationExpression.Arguments.Count; i++) {
+						result.AddChild ((Expression)arrayCreationExpression.Arguments [i].Accept (this), ArrayCreateExpression.Roles.Argument);
 						if (commaLocations != null && i > 0)
 							result.AddChild (new CSharpTokenNode (Convert (commaLocations [commaLocations.Count - i]), 1), ArrayCreateExpression.Roles.Comma);
 					}
@@ -2264,42 +2272,42 @@ namespace ICSharpCode.NRefactory.CSharp
 					var loc = LocationsBag.GetLocations (next);
 					spec.AddChild (new CSharpTokenNode (Convert (next.Location), 1), ArraySpecifier.Roles.LBracket);
 					if (loc != null)
-						result.AddChild (new CSharpTokenNode (Convert (loc[0]), 1), ArraySpecifier.Roles.RBracket);
+						result.AddChild (new CSharpTokenNode (Convert (loc [0]), 1), ArraySpecifier.Roles.RBracket);
 					result.AddChild (spec, ArrayCreateExpression.AdditionalArraySpecifierRole);
 					next = next.Next;
 				}
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), ArrayCreateExpression.Roles.RBracket);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), ArrayCreateExpression.Roles.RBracket);
 				
 				if (arrayCreationExpression.Initializers != null && arrayCreationExpression.Initializers.Count != 0) {
 					var initLocation = LocationsBag.GetLocations (arrayCreationExpression.Initializers);
-					ArrayInitializerExpression initializer = new ArrayInitializerExpression();
+					ArrayInitializerExpression initializer = new ArrayInitializerExpression ();
 					
 					initializer.AddChild (new CSharpTokenNode (Convert (arrayCreationExpression.Initializers.Location), 1), ArrayCreateExpression.Roles.LBrace);
 					var commaLocations = LocationsBag.GetLocations (arrayCreationExpression.Initializers.Elements);
 					for (int i = 0; i < arrayCreationExpression.Initializers.Count; i++) {
-						initializer.AddChild ((Expression)arrayCreationExpression.Initializers[i].Accept (this), ArrayInitializerExpression.Roles.Expression);
+						initializer.AddChild ((Expression)arrayCreationExpression.Initializers [i].Accept (this), ArrayInitializerExpression.Roles.Expression);
 						if (commaLocations != null && i > 0) {
 							initializer.AddChild (new CSharpTokenNode (Convert (commaLocations [commaLocations.Count - i]), 1), IndexerExpression.Roles.Comma);
 						}
 					}
 					
 					if (initLocation != null)
-						initializer.AddChild (new CSharpTokenNode (Convert (initLocation[initLocation.Count - 1]), 1), ArrayCreateExpression.Roles.RBrace);
+						initializer.AddChild (new CSharpTokenNode (Convert (initLocation [initLocation.Count - 1]), 1), ArrayCreateExpression.Roles.RBrace);
 					result.AddChild (initializer, ArrayCreateExpression.InitializerRole);
 				}
 				
 				return result;
 			}
-			
+
 			public override object Visit (This thisExpression)
 			{
 				var result = new ThisReferenceExpression ();
 				result.Location = Convert (thisExpression.Location);
 				return result;
 			}
-			
+
 			public override object Visit (ArglistAccess argListAccessExpression)
 			{
 				var result = new UndocumentedExpression () {
@@ -2308,7 +2316,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (argListAccessExpression.Location), "__arglist".Length), UndocumentedExpression.Roles.Keyword);
 				return result;
 			}
-			
+
 			#region Undocumented expressions
 			public override object Visit (Arglist argListExpression)
 			{
@@ -2316,52 +2324,52 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (argListExpression.Location), "__arglist".Length), UndocumentedExpression.Roles.Keyword);
 				var location = LocationsBag.GetLocations (argListExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UndocumentedExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), UndocumentedExpression.Roles.LPar);
 				
 				AddArguments (result, location, argListExpression.Arguments);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UndocumentedExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), UndocumentedExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (MakeRefExpr makeRefExpr)
 			{
 				var result = new UndocumentedExpression () { UndocumentedExpressionType = UndocumentedExpressionType.RefValue };
 				result.AddChild (new CSharpTokenNode (Convert (makeRefExpr.Location), "__makeref".Length), UndocumentedExpression.Roles.Keyword);
 				var location = LocationsBag.GetLocations (makeRefExpr);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UndocumentedExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), UndocumentedExpression.Roles.LPar);
 				if (makeRefExpr.Expr != null)
 					result.AddChild ((Expression)makeRefExpr.Expr.Accept (this), UndocumentedExpression.Roles.Argument);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UndocumentedExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), UndocumentedExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (RefTypeExpr refTypeExpr)
 			{
 				var result = new UndocumentedExpression () { UndocumentedExpressionType = UndocumentedExpressionType.RefValue };
 				result.AddChild (new CSharpTokenNode (Convert (refTypeExpr.Location), "__reftype".Length), UndocumentedExpression.Roles.Keyword);
 				var location = LocationsBag.GetLocations (refTypeExpr);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UndocumentedExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), UndocumentedExpression.Roles.LPar);
 				
 				if (refTypeExpr.Expr != null)
 					result.AddChild ((Expression)refTypeExpr.Expr.Accept (this), UndocumentedExpression.Roles.Argument);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UndocumentedExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), UndocumentedExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (RefValueExpr refValueExpr)
 			{
 				var result = new UndocumentedExpression () { UndocumentedExpressionType = UndocumentedExpressionType.RefValue };
 				result.AddChild (new CSharpTokenNode (Convert (refValueExpr.Location), "__refvalue".Length), UndocumentedExpression.Roles.Keyword);
 				var location = LocationsBag.GetLocations (refValueExpr);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), UndocumentedExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), UndocumentedExpression.Roles.LPar);
 				
 				
 				if (refValueExpr.Expr != null)
@@ -2371,9 +2379,10 @@ namespace ICSharpCode.NRefactory.CSharp
 					result.AddChild ((Expression)refValueExpr.FullNamedExpression.Accept (this), UndocumentedExpression.Roles.Argument);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), UndocumentedExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), UndocumentedExpression.Roles.RPar);
 				return result;
 			}
+
 			#endregion
 			
 			public override object Visit (TypeOf typeOfExpression)
@@ -2381,51 +2390,51 @@ namespace ICSharpCode.NRefactory.CSharp
 				var result = new TypeOfExpression ();
 				var location = LocationsBag.GetLocations (typeOfExpression);
 				result.AddChild (new CSharpTokenNode (Convert (typeOfExpression.Location), "typeof".Length), TypeOfExpression.Roles.Keyword);
-				result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
+				result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), TypeOfExpression.Roles.LPar);
 				result.AddChild (ConvertToType (typeOfExpression.TypeExpression), TypeOfExpression.Roles.Type);
-				result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
+				result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), TypeOfExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (SizeOf sizeOfExpression)
 			{
 				var result = new SizeOfExpression ();
 				var location = LocationsBag.GetLocations (sizeOfExpression);
 				result.AddChild (new CSharpTokenNode (Convert (sizeOfExpression.Location), "sizeof".Length), TypeOfExpression.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), TypeOfExpression.Roles.LPar);
 				result.AddChild (ConvertToType (sizeOfExpression.QueriedType), TypeOfExpression.Roles.Type);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), TypeOfExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (CheckedExpr checkedExpression)
 			{
 				var result = new CheckedExpression ();
 				var location = LocationsBag.GetLocations (checkedExpression);
 				result.AddChild (new CSharpTokenNode (Convert (checkedExpression.Location), "checked".Length), TypeOfExpression.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), TypeOfExpression.Roles.LPar);
 				result.AddChild ((Expression)checkedExpression.Expr.Accept (this), TypeOfExpression.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), TypeOfExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (UnCheckedExpr uncheckedExpression)
 			{
 				var result = new UncheckedExpression ();
 				var location = LocationsBag.GetLocations (uncheckedExpression);
 				result.AddChild (new CSharpTokenNode (Convert (uncheckedExpression.Location), "unchecked".Length), TypeOfExpression.Roles.Keyword);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.LPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), TypeOfExpression.Roles.LPar);
 				result.AddChild ((Expression)uncheckedExpression.Expr.Accept (this), TypeOfExpression.Roles.Expression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), TypeOfExpression.Roles.RPar);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), TypeOfExpression.Roles.RPar);
 				return result;
 			}
-			
+
 			public override object Visit (ElementAccess elementAccessExpression)
 			{
 				IndexerExpression result = new IndexerExpression ();
@@ -2435,33 +2444,33 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (elementAccessExpression.Location), 1), TypeOfExpression.Roles.LBracket);
 				AddArguments (result, location, elementAccessExpression.Arguments);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), TypeOfExpression.Roles.RBracket);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), TypeOfExpression.Roles.RBracket);
 				return result;
 			}
-			
+
 			public override object Visit (BaseThis baseAccessExpression)
 			{
 				var result = new BaseReferenceExpression ();
 				result.Location = Convert (baseAccessExpression.Location);
 				return result;
 			}
-			
+
 			public override object Visit (StackAlloc stackAllocExpression)
 			{
 				var result = new StackAllocExpression ();
 				
 				var location = LocationsBag.GetLocations (stackAllocExpression);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "stackalloc".Length), StackAllocExpression.Roles.Keyword);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "stackalloc".Length), StackAllocExpression.Roles.Keyword);
 				result.AddChild (ConvertToType (stackAllocExpression.TypeExpression), StackAllocExpression.Roles.Type);
 				if (location != null && location.Count > 1)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), StackAllocExpression.Roles.LBracket);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), StackAllocExpression.Roles.LBracket);
 				result.AddChild ((Expression)stackAllocExpression.CountExpression.Accept (this), StackAllocExpression.Roles.Expression);
 				if (location != null && location.Count > 2)
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), StackAllocExpression.Roles.RBracket);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), 1), StackAllocExpression.Roles.RBracket);
 				return result;
 			}
-			
+
 			public override object Visit (SimpleAssign simpleAssign)
 			{
 				var result = new AssignmentExpression ();
@@ -2475,7 +2484,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 				return result;
 			}
-			
+
 			public override object Visit (CompoundAssign compoundAssign)
 			{
 				var result = new AssignmentExpression ();
@@ -2520,19 +2529,19 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((Expression)compoundAssign.Source.Accept (this), AssignmentExpression.RightRole);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.AnonymousMethodExpression anonymousMethodExpression)
 			{
 				var result = new AnonymousMethodExpression ();
 				var location = LocationsBag.GetLocations (anonymousMethodExpression);
 				if (location != null) {
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "delegate".Length), AnonymousMethodExpression.Roles.Keyword);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "delegate".Length), AnonymousMethodExpression.Roles.Keyword);
 					
 					if (location.Count > 1) {
 						result.HasParameterList = true;
-						result.AddChild (new CSharpTokenNode (Convert (location[1]), 1), AnonymousMethodExpression.Roles.LPar);
+						result.AddChild (new CSharpTokenNode (Convert (location [1]), 1), AnonymousMethodExpression.Roles.LPar);
 						AddParameter (result, anonymousMethodExpression.Parameters);
-						result.AddChild (new CSharpTokenNode (Convert (location[2]), 1), AnonymousMethodExpression.Roles.RPar);
+						result.AddChild (new CSharpTokenNode (Convert (location [2]), 1), AnonymousMethodExpression.Roles.RPar);
 					}
 				}
 				result.AddChild ((BlockStatement)anonymousMethodExpression.Block.Accept (this), AnonymousMethodExpression.Roles.Body);
@@ -2565,12 +2574,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				return result;
 			}
-			
+
 			public override object Visit (ConstInitializer constInitializer)
 			{
 				return constInitializer.Expr.Accept (this);
 			}
-			
+
 			public override object Visit (ArrayInitializer arrayInitializer)
 			{
 				var result = new ArrayInitializerExpression ();
@@ -2578,19 +2587,19 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (arrayInitializer.Location), "{".Length), ArrayInitializerExpression.Roles.LBrace);
 				var commaLocations = LocationsBag.GetLocations (arrayInitializer.Elements);
 				for (int i = 0; i < arrayInitializer.Count; i++) {
-					result.AddChild ((Expression)arrayInitializer[i].Accept (this), ArrayInitializerExpression.Roles.Expression);
+					result.AddChild ((Expression)arrayInitializer [i].Accept (this), ArrayInitializerExpression.Roles.Expression);
 					if (commaLocations != null && i < commaLocations.Count)
-						result.AddChild (new CSharpTokenNode (Convert (commaLocations[i]), ",".Length), ArrayInitializerExpression.Roles.Comma);
+						result.AddChild (new CSharpTokenNode (Convert (commaLocations [i]), ",".Length), ArrayInitializerExpression.Roles.Comma);
 				}
 				
 				if (location != null) {
 					if (location.Count == 2) // optional comma
-						result.AddChild (new CSharpTokenNode (Convert (location[1]), ",".Length), ArrayInitializerExpression.Roles.Comma);
-					result.AddChild (new CSharpTokenNode (Convert (location[location.Count - 1]), "}".Length), ArrayInitializerExpression.Roles.RBrace);
+						result.AddChild (new CSharpTokenNode (Convert (location [1]), ",".Length), ArrayInitializerExpression.Roles.Comma);
+					result.AddChild (new CSharpTokenNode (Convert (location [location.Count - 1]), "}".Length), ArrayInitializerExpression.Roles.RBrace);
 				}
 				return result;
 			}
-			
+
 			#endregion
 			
 			#region LINQ expressions
@@ -2605,9 +2614,9 @@ namespace ICSharpCode.NRefactory.CSharp
 					QueryClause clause = (QueryClause)currentClause.Accept (this);
 					if (clause is QueryContinuationClause) {
 						// insert preceding query at beginning of QueryContinuationClause
-						clause.InsertChildAfter(null, result, QueryContinuationClause.PrecedingQueryRole);
+						clause.InsertChildAfter (null, result, QueryContinuationClause.PrecedingQueryRole);
 						// create a new QueryExpression for the remaining query
-						result = new QueryExpression();
+						result = new QueryExpression ();
 					}
 					result.AddChild (clause, QueryExpression.ClauseRole);
 					currentClause = currentClause.next;
@@ -2615,13 +2624,13 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.QueryStartClause queryStart)
 			{
 				if (queryStart.Expr == null) {
 					var intoClause = new QueryContinuationClause ();
 					intoClause.AddChild (new CSharpTokenNode (Convert (queryStart.Location), "into".Length), QueryContinuationClause.IntoKeywordRole);
-					intoClause.AddChild (new Identifier (queryStart.IntoVariable.Name, Convert(queryStart.IntoVariable.Location)), QueryContinuationClause.Roles.Identifier);
+					intoClause.AddChild (new Identifier (queryStart.IntoVariable.Name, Convert (queryStart.IntoVariable.Location)), QueryContinuationClause.Roles.Identifier);
 					return intoClause;
 				}
 				
@@ -2633,14 +2642,14 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (queryStart.IdentifierType != null)
 					fromClause.AddChild (ConvertToType (queryStart.IdentifierType), QueryFromClause.Roles.Type);
 				
-				fromClause.AddChild (new Identifier (queryStart.IntoVariable.Name, Convert(queryStart.IntoVariable.Location)), QueryFromClause.Roles.Identifier);
+				fromClause.AddChild (new Identifier (queryStart.IntoVariable.Name, Convert (queryStart.IntoVariable.Location)), QueryFromClause.Roles.Identifier);
 				
 				if (location != null)
-					fromClause.AddChild (new CSharpTokenNode (Convert (location[0]), "in".Length), QueryFromClause.InKeywordRole);
+					fromClause.AddChild (new CSharpTokenNode (Convert (location [0]), "in".Length), QueryFromClause.InKeywordRole);
 				fromClause.AddChild ((Expression)queryStart.Expr.Accept (this), QueryFromClause.Roles.Expression);
 				return fromClause;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.SelectMany queryStart)
 			{
 				var fromClause = new QueryFromClause ();
@@ -2651,14 +2660,14 @@ namespace ICSharpCode.NRefactory.CSharp
 				if (queryStart.IdentifierType != null)
 					fromClause.AddChild (ConvertToType (queryStart.IdentifierType), QueryFromClause.Roles.Type);
 				
-				fromClause.AddChild (new Identifier (queryStart.IntoVariable.Name, Convert(queryStart.IntoVariable.Location)), QueryFromClause.Roles.Identifier);
+				fromClause.AddChild (new Identifier (queryStart.IntoVariable.Name, Convert (queryStart.IntoVariable.Location)), QueryFromClause.Roles.Identifier);
 				
 				if (location != null)
-					fromClause.AddChild (new CSharpTokenNode (Convert (location[0]), "in".Length), QueryFromClause.InKeywordRole);
+					fromClause.AddChild (new CSharpTokenNode (Convert (location [0]), "in".Length), QueryFromClause.InKeywordRole);
 				fromClause.AddChild ((Expression)queryStart.Expr.Accept (this), QueryFromClause.Roles.Expression);
 				return fromClause;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.Select sel)
 			{
 				var result = new QuerySelectClause ();
@@ -2666,7 +2675,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild ((Expression)sel.Expr.Accept (this), QueryWhereClause.Roles.Expression);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.GroupBy groupBy)
 			{
 				var result = new QueryGroupClause ();
@@ -2674,11 +2683,11 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (groupBy.Location), "group".Length), QueryGroupClause.GroupKeywordRole);
 				result.AddChild ((Expression)groupBy.ElementSelector.Accept (this), QueryGroupClause.KeyRole);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "by".Length), QueryGroupClause.ByKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "by".Length), QueryGroupClause.ByKeywordRole);
 				result.AddChild ((Expression)groupBy.Expr.Accept (this), QueryGroupClause.ProjectionRole);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.Let l)
 			{
 				var result = new QueryLetClause ();
@@ -2687,21 +2696,21 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new CSharpTokenNode (Convert (l.Location), "let".Length), QueryLetClause.Roles.Keyword);
 				result.AddChild (new Identifier (l.IntoVariable.Name, Convert (l.IntoVariable.Location)), Identifier.Roles.Identifier);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), 1), QueryLetClause.Roles.Assign);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), 1), QueryLetClause.Roles.Assign);
 				result.AddChild ((Expression)l.Expr.Accept (this), QueryLetClause.Roles.Expression);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.Where w)
 			{
 				var result = new QueryWhereClause ();
 				var location = LocationsBag.GetLocations (w);
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "where".Length), QueryWhereClause.Roles.Keyword);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "where".Length), QueryWhereClause.Roles.Keyword);
 				result.AddChild ((Expression)w.Expr.Accept (this), QueryWhereClause.Roles.Condition);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.Join join)
 			{
 				var result = new QueryJoinClause ();
@@ -2711,21 +2720,21 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new Identifier (join.JoinVariable.Name, Convert (join.JoinVariable.Location)), Identifier.Roles.Identifier);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "in".Length), QueryJoinClause.InKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "in".Length), QueryJoinClause.InKeywordRole);
 				
 				result.AddChild ((Expression)join.Expr.Accept (this), QueryJoinClause.Roles.Expression);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), "on".Length), QueryJoinClause.OnKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), "on".Length), QueryJoinClause.OnKeywordRole);
 				// TODO: on expression
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), "equals".Length), QueryJoinClause.EqualsKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), "equals".Length), QueryJoinClause.EqualsKeywordRole);
 				// TODO: equals expression
 				
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.GroupJoin join)
 			{
 				var result = new QueryJoinClause ();
@@ -2735,26 +2744,26 @@ namespace ICSharpCode.NRefactory.CSharp
 				result.AddChild (new Identifier (join.JoinVariable.Name, Convert (join.JoinVariable.Location)), Identifier.Roles.Identifier);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[0]), "in".Length), QueryJoinClause.InKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [0]), "in".Length), QueryJoinClause.InKeywordRole);
 				
 				result.AddChild ((Expression)join.Expr.Accept (this), QueryJoinClause.Roles.Expression);
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[1]), "on".Length), QueryJoinClause.OnKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [1]), "on".Length), QueryJoinClause.OnKeywordRole);
 				
 				// TODO: on expression
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[2]), "equals".Length), QueryJoinClause.EqualsKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [2]), "equals".Length), QueryJoinClause.EqualsKeywordRole);
 				// TODO: equals expression
 				
 				if (location != null)
-					result.AddChild (new CSharpTokenNode (Convert (location[3]), "into".Length), QueryJoinClause.IntoKeywordRole);
+					result.AddChild (new CSharpTokenNode (Convert (location [3]), "into".Length), QueryJoinClause.IntoKeywordRole);
 				
 				result.AddChild (new Identifier (join.JoinVariable.Name, Convert (join.JoinVariable.Location)), Identifier.Roles.Identifier);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.OrderByAscending orderByAscending)
 			{
 				var result = new QueryOrderClause ();
@@ -2765,12 +2774,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetLocations (orderByAscending);
 				if (location != null) {
 					ordering.Direction = QueryOrderingDirection.Ascending;
-					ordering.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
+					ordering.AddChild (new CSharpTokenNode (Convert (location [0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
 				}
 				result.AddChild (ordering, QueryOrderClause.OrderingRole);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.OrderByDescending orderByDescending)
 			{
 				var result = new QueryOrderClause ();
@@ -2781,12 +2790,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetLocations (orderByDescending);
 				if (location != null) {
 					ordering.Direction = QueryOrderingDirection.Descending;
-					ordering.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
+					ordering.AddChild (new CSharpTokenNode (Convert (location [0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
 				}
 				result.AddChild (ordering, QueryOrderClause.OrderingRole);
 				return result;
 		}
-			
+
 			public override object Visit (Mono.CSharp.Linq.ThenByAscending thenByAscending)
 			{
 				var result = new QueryOrderClause ();
@@ -2797,12 +2806,12 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetLocations (thenByAscending);
 				if (location != null) {
 					ordering.Direction = QueryOrderingDirection.Ascending;
-					ordering.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
+					ordering.AddChild (new CSharpTokenNode (Convert (location [0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
 				}
 				result.AddChild (ordering, QueryOrderClause.OrderingRole);
 				return result;
 			}
-			
+
 			public override object Visit (Mono.CSharp.Linq.ThenByDescending thenByDescending)
 			{
 				var result = new QueryOrderClause ();
@@ -2813,7 +2822,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				var location = LocationsBag.GetLocations (thenByDescending);
 				if (location != null) {
 					ordering.Direction = QueryOrderingDirection.Descending;
-					ordering.AddChild (new CSharpTokenNode (Convert (location[0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
+					ordering.AddChild (new CSharpTokenNode (Convert (location [0]), "ascending".Length), QueryWhereClause.Roles.Keyword);
 				}
 				result.AddChild (ordering, QueryOrderClause.OrderingRole);
 				return result;
@@ -2841,7 +2850,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			
 			node.AddChild (comment, AstNode.Roles.Comment);
 		}
-		
+
 		static void InsertComments (CompilerCompilationUnit top, ConversionVisitor conversionVisitor)
 		{
 			foreach (var special in top.SpecialsBag.Specials) {
@@ -2858,7 +2867,7 @@ namespace ICSharpCode.NRefactory.CSharp
 				}
 			}
 		}
-		
+
 		internal static CompilationUnit Parse (CompilerCompilationUnit top)
 		{
 			if (top == null)
@@ -2875,47 +2884,47 @@ namespace ICSharpCode.NRefactory.CSharp
 			
 			public override void Print (AbstractMessage msg)
 			{
-				Console.WriteLine (msg.MessageType + " (" + msg.Location + ")" + ": "+ msg.Text);
+				Console.WriteLine (msg.MessageType + " (" + msg.Location + ")" + ": " + msg.Text);
 				base.Print (msg);
 //				Error newError = new Error (msg.IsWarning ? ErrorType.Warning : ErrorType.Error, msg.Location.Row, msg.Location.Column, msg.Text);
 //				Errors.Add (newError);
 			}
 		}
 		ErrorReportPrinter errorReportPrinter = new ErrorReportPrinter ();
-		
+
 		public ErrorReportPrinter ErrorPrinter {
 			get {
 				return errorReportPrinter;
 			}
 		}
-		
+
 		public bool HasErrors {
 			get {
 				return errorReportPrinter.ErrorsCount + errorReportPrinter.FatalCounter > 0;
 			}
 		}
-		
+
 		public bool HasWarnings {
 			get {
 				return errorReportPrinter.WarningsCount > 0;
 			}
 		}
-		
+
 		public CompilationUnit Parse (TextReader reader)
 		{
 			// TODO: can we optimize this to avoid the text->stream->text roundtrip?
 			using (MemoryStream stream = new MemoryStream ()) {
-				StreamWriter w = new StreamWriter(stream, Encoding.UTF8);
+				StreamWriter w = new StreamWriter (stream, Encoding.UTF8);
 				char[] buffer = new char[2048];
 				int read;
 				while ((read = reader.ReadBlock(buffer, 0, buffer.Length)) > 0)
-					w.Write(buffer, 0, read);
-				w.Flush(); // we can't close the StreamWriter because that would also close the MemoryStream
+					w.Write (buffer, 0, read);
+				w.Flush (); // we can't close the StreamWriter because that would also close the MemoryStream
 				stream.Position = 0;
-				return Parse(stream);
+				return Parse (stream);
 			}
 		}
-		
+
 		public CompilationUnit Parse (Stream stream)
 		{
 			lock (CompilerCallableEntryPoint.parseLock) {
@@ -2928,41 +2937,41 @@ namespace ICSharpCode.NRefactory.CSharp
 				return conversionVisitor.Unit;
 			}
 		}
-		
-		public IEnumerable<AttributedNode> ParseTypeMembers(TextReader reader)
+
+		public IEnumerable<AttributedNode> ParseTypeMembers (TextReader reader)
 		{
-			string code = "unsafe partial class MyClass { " + reader.ReadToEnd() + "}";
-			var cu = Parse(new StringReader(code));
-			var td = cu.Children.FirstOrDefault() as TypeDeclaration;
+			string code = "unsafe partial class MyClass { " + reader.ReadToEnd () + "}";
+			var cu = Parse (new StringReader (code));
+			var td = cu.Children.FirstOrDefault () as TypeDeclaration;
 			if (td != null)
 				return td.Members;
 			return Enumerable.Empty<AttributedNode> ();
 		}
-		
-		public IEnumerable<Statement> ParseStatements(TextReader reader)
+
+		public IEnumerable<Statement> ParseStatements (TextReader reader)
 		{
-			string code = "void M() { " + reader.ReadToEnd() + "}";
-			var members = ParseTypeMembers(new StringReader(code));
-			var method = members.FirstOrDefault() as MethodDeclaration;
+			string code = "void M() { " + reader.ReadToEnd () + "}";
+			var members = ParseTypeMembers (new StringReader (code));
+			var method = members.FirstOrDefault () as MethodDeclaration;
 			if (method != null && method.Body != null)
 				return method.Body.Statements;
 			return Enumerable.Empty<Statement> ();
 		}
-		
-		public AstType ParseTypeReference(TextReader reader)
+
+		public AstType ParseTypeReference (TextReader reader)
 		{
-			string code = reader.ReadToEnd() + " a;";
-			var members = ParseTypeMembers(new StringReader(code));
-			var field = members.FirstOrDefault() as FieldDeclaration;
-			Console.WriteLine ("field : " +field.ReturnType);
+			string code = reader.ReadToEnd () + " a;";
+			var members = ParseTypeMembers (new StringReader (code));
+			var field = members.FirstOrDefault () as FieldDeclaration;
+			Console.WriteLine ("field : " + field.ReturnType);
 			if (field != null)
 				return field.ReturnType;
 			return AstType.Null;
 		}
-		
-		public AstNode ParseExpression(TextReader reader)
+
+		public AstNode ParseExpression (TextReader reader)
 		{
-			var es = ParseStatements(new StringReader("tmp = " + reader.ReadToEnd() + ";")).FirstOrDefault() as ExpressionStatement;
+			var es = ParseStatements (new StringReader ("tmp = " + reader.ReadToEnd () + ";")).FirstOrDefault () as ExpressionStatement;
 			if (es != null) {
 				AssignmentExpression ae = es.Expression as AssignmentExpression;
 				if (ae != null)
@@ -2974,10 +2983,10 @@ namespace ICSharpCode.NRefactory.CSharp
 		/// <summary>
 		/// Parses a file snippet; guessing what the code snippet represents (compilation unit, type members, block, type reference, expression).
 		/// </summary>
-		public AstNode ParseSnippet(TextReader reader)
+		public AstNode ParseSnippet (TextReader reader)
 		{
 			// TODO: add support for parsing a part of a file
-			throw new NotImplementedException();
+			throw new NotImplementedException ();
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/ParsedFile.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/ParsedFile.cs
index fd9bfab20..0fe039f8c 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/ParsedFile.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/ParsedFile.cs
@@ -17,6 +17,7 @@ namespace ICSharpCode.NRefactory.CSharp
 		readonly string fileName;
 		readonly UsingScope rootUsingScope;
 		IList<ITypeDefinition> topLevelTypeDefinitions = new List<ITypeDefinition>();
+		IList<IAttribute> assemblyAttributes = new List<IAttribute>();
 		IList<UsingScope> usingScopes = new List<UsingScope>();
 		
 		protected override void FreezeInternal()
@@ -24,6 +25,7 @@ namespace ICSharpCode.NRefactory.CSharp
 			base.FreezeInternal();
 			rootUsingScope.Freeze();
 			topLevelTypeDefinitions = FreezeList(topLevelTypeDefinitions);
+			assemblyAttributes = FreezeList(assemblyAttributes);
 			usingScopes = FreezeList(usingScopes);
 		}
 		
@@ -53,6 +55,10 @@ namespace ICSharpCode.NRefactory.CSharp
 			get { return topLevelTypeDefinitions; }
 		}
 		
+		public IList<IAttribute> AssemblyAttributes {
+			get { return assemblyAttributes; }
+		}
+		
 		public UsingScope GetUsingScope(AstLocation location)
 		{
 			foreach (UsingScope scope in usingScopes) {
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs
index b3dfd30b5..66865d53c 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/TypeSystemConvertVisitor.cs
@@ -5,7 +5,9 @@ using System;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Linq;
+using ICSharpCode.NRefactory.CSharp.Analysis;
 using ICSharpCode.NRefactory.CSharp.Resolver;
+using ICSharpCode.NRefactory.CSharp.Resolver.ConstantValues;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.NRefactory.TypeSystem.Implementation;
 using ICSharpCode.NRefactory.Utils;
@@ -79,7 +81,11 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		
 		#region Using Declarations
-		// TODO: extern aliases
+		public override IEntity VisitExternAliasDeclaration(ExternAliasDeclaration externAliasDeclaration, object data)
+		{
+			usingScope.ExternAliases.Add(externAliasDeclaration.Name);
+			return null;
+		}
 		
 		public override IEntity VisitUsingDeclaration(UsingDeclaration usingDeclaration, object data)
 		{
@@ -114,8 +120,6 @@ namespace ICSharpCode.NRefactory.CSharp
 		}
 		#endregion
 		
-		// TODO: assembly attributes
-		
 		#region Type Definitions
 		DefaultTypeDefinition CreateTypeDefinition(string name)
 		{
@@ -155,6 +159,8 @@ namespace ICSharpCode.NRefactory.CSharp
 				member.AcceptVisitor(this, data);
 			}
 			
+			td.HasExtensionMethods = td.Methods.Any(m => m.IsExtensionMethod);
+			
 			currentTypeDefinition = (DefaultTypeDefinition)currentTypeDefinition.DeclaringTypeDefinition;
 			return td;
 		}
@@ -166,7 +172,6 @@ namespace ICSharpCode.NRefactory.CSharp
 			td.Region = MakeRegion(delegateDeclaration);
 			td.BaseTypes.Add(multicastDelegateReference);
 			
-			ConvertAttributes(td.Attributes, delegateDeclaration.Attributes);
 			ApplyModifiers(td, delegateDeclaration.Modifiers);
 			td.IsSealed = true; // delegates are implicitly sealed
 			
@@ -177,6 +182,15 @@ namespace ICSharpCode.NRefactory.CSharp
 			ConvertParameters(parameters, delegateDeclaration.Parameters);
 			AddDefaultMethodsToDelegate(td, returnType, parameters);
 			
+			foreach (AttributeSection section in delegateDeclaration.Attributes) {
+				if (section.AttributeTarget == "return") {
+					ConvertAttributes(td.Methods.Single(m => m.Name == "Invoke").ReturnTypeAttributes, section);
+					ConvertAttributes(td.Methods.Single(m => m.Name == "EndInvoke").ReturnTypeAttributes, section);
+				} else {
+					ConvertAttributes(td.Attributes, section);
+				}
+			}
+			
 			currentTypeDefinition = (DefaultTypeDefinition)currentTypeDefinition.DeclaringTypeDefinition;
 			return td;
 		}
@@ -448,7 +462,13 @@ namespace ICSharpCode.NRefactory.CSharp
 			DefaultAccessor a = new DefaultAccessor();
 			a.Accessibility = GetAccessibility(accessor.Modifiers) ?? defaultAccessibility;
 			a.Region = MakeRegion(accessor);
-			ConvertAttributes(a.Attributes, accessor.Attributes);
+			foreach (AttributeSection section in accessor.Attributes) {
+				if (section.AttributeTarget == "return") {
+					ConvertAttributes(a.ReturnTypeAttributes, section);
+				} else if (section.AttributeTarget != "param") {
+					ConvertAttributes(a.Attributes, section);
+				}
+			}
 			return a;
 		}
 		#endregion
@@ -464,12 +484,26 @@ namespace ICSharpCode.NRefactory.CSharp
 				
 				ev.Region = isSingleEvent ? MakeRegion(eventDeclaration) : MakeRegion(vi);
 				ev.BodyRegion = MakeRegion(vi);
-				ConvertAttributes(ev.Attributes, eventDeclaration.Attributes);
 				
 				ApplyModifiers(ev, modifiers);
 				
 				ev.ReturnType = ConvertType(eventDeclaration.ReturnType);
 				
+				if (eventDeclaration.Attributes.Any(a => a.AttributeTarget == "method")) {
+					ev.AddAccessor = ev.RemoveAccessor = new DefaultAccessor { Accessibility = ev.Accessibility };
+				} else {
+					// if there's no attributes on the accessors, we can re-use the shared accessor instance
+					ev.AddAccessor = ev.RemoveAccessor = DefaultAccessor.GetFromAccessibility(ev.Accessibility);
+				}
+				foreach (AttributeSection section in eventDeclaration.Attributes) {
+					if (section.AttributeTarget == "method") {
+						// as we use the same instance for AddAccessor and RemoveAccessor, we only need to add the attribute once
+						ConvertAttributes(ev.AddAccessor.Attributes, section);
+					} else if (section.AttributeTarget != "field") {
+						ConvertAttributes(ev.Attributes, section);
+					}
+				}
+				
 				currentTypeDefinition.Events.Add(ev);
 			}
 			return isSingleEvent ? ev : null;
@@ -537,12 +571,68 @@ namespace ICSharpCode.NRefactory.CSharp
 		#endregion
 		
 		#region Attributes
+		public override IEntity VisitAttributeSection(AttributeSection attributeSection, object data)
+		{
+			// non-assembly attributes are handled by their parent entity
+			if (attributeSection.AttributeTarget == "assembly") {
+				ConvertAttributes(parsedFile.AssemblyAttributes, attributeSection);
+			}
+			return null;
+		}
+		
 		void ConvertAttributes(IList<IAttribute> outputList, IEnumerable<AttributeSection> attributes)
 		{
 			foreach (AttributeSection section in attributes) {
-				throw new NotImplementedException();
+				ConvertAttributes(outputList, section);
 			}
 		}
+		
+		void ConvertAttributes(IList<IAttribute> outputList, AttributeSection attributeSection)
+		{
+			foreach (CSharp.Attribute attr in attributeSection.Attributes) {
+				outputList.Add(ConvertAttribute(attr));
+			}
+		}
+		
+		IAttribute ConvertAttribute(CSharp.Attribute attr)
+		{
+			DomRegion region = MakeRegion(attr);
+			ITypeReference type = ConvertType(attr.Type);
+			if (!attr.Type.GetChildByRole(AstNode.Roles.Identifier).IsVerbatim) {
+				// Try to add "Attribute" suffix, but only if the identifier
+				// (=last identifier in fully qualified name) isn't a verbatim identifier.
+				SimpleTypeOrNamespaceReference st = type as SimpleTypeOrNamespaceReference;
+				MemberTypeOrNamespaceReference mt = type as MemberTypeOrNamespaceReference;
+				if (st != null)
+					type = new AttributeTypeReference(st, st.AddSuffix("Attribute"));
+				else if (mt != null)
+					type = new AttributeTypeReference(mt, mt.AddSuffix("Attribute"));
+			}
+			List<IConstantValue> positionalArguments = null;
+			List<KeyValuePair<string, IConstantValue>> namedCtorArguments = null;
+			List<KeyValuePair<string, IConstantValue>> namedArguments = null;
+			foreach (Expression expr in attr.Arguments) {
+				NamedArgumentExpression nae = expr as NamedArgumentExpression;
+				if (nae != null) {
+					if (namedCtorArguments == null)
+						namedCtorArguments = new List<KeyValuePair<string, IConstantValue>>();
+					namedCtorArguments.Add(new KeyValuePair<string, IConstantValue>(nae.Identifier, ConvertAttributeArgument(nae.Expression)));
+				} else {
+					AssignmentExpression ae = expr as AssignmentExpression;
+					if (ae != null && ae.Left is IdentifierExpression && ae.Operator == AssignmentOperatorType.Assign) {
+						string name = ((IdentifierExpression)ae.Left).Identifier;
+						if (namedArguments == null)
+							namedArguments = new List<KeyValuePair<string, IConstantValue>>();
+						namedArguments.Add(new KeyValuePair<string, IConstantValue>(name, ConvertAttributeArgument(nae.Expression)));
+					} else {
+						if (positionalArguments == null)
+							positionalArguments = new List<IConstantValue>();
+						positionalArguments.Add(ConvertAttributeArgument(nae.Expression));
+					}
+				}
+			}
+			return new CSharpAttribute(type, region, positionalArguments, namedCtorArguments, namedArguments);
+		}
 		#endregion
 		
 		#region Types
@@ -652,8 +742,188 @@ namespace ICSharpCode.NRefactory.CSharp
 		#region Constant Values
 		IConstantValue ConvertConstantValue(ITypeReference targetType, AstNode expression)
 		{
-			// TODO: implement ConvertConstantValue
-			return new SimpleConstantValue(targetType, null);
+			ConstantValueBuilder b = new ConstantValueBuilder();
+			b.convertVisitor = this;
+			ConstantExpression c = expression.AcceptVisitor(b, null);
+			if (c == null)
+				return null;
+			PrimitiveConstantExpression pc = c as PrimitiveConstantExpression;
+			if (pc != null && pc.Type == targetType) {
+				// Save memory by directly using a SimpleConstantValue.
+				return new SimpleConstantValue(targetType, pc.Value);
+			}
+			// cast to the desired type
+			return new CSharpConstantValue(new ConstantCast(targetType, c), usingScope, currentTypeDefinition);
+		}
+		
+		IConstantValue ConvertAttributeArgument(Expression expression)
+		{
+			ConstantValueBuilder b = new ConstantValueBuilder();
+			b.convertVisitor = this;
+			b.isAttributeArgument = true;
+			ConstantExpression c = expression.AcceptVisitor(b, null);
+			if (c == null)
+				return null;
+			PrimitiveConstantExpression pc = c as PrimitiveConstantExpression;
+			if (pc != null) {
+				// Save memory by directly using a SimpleConstantValue.
+				return new SimpleConstantValue(pc.Type, pc.Value);
+			} else {
+				return new CSharpConstantValue(c, usingScope, currentTypeDefinition);
+			}
+		}
+		
+		sealed class ConstantValueBuilder : DepthFirstAstVisitor<object, ConstantExpression>
+		{
+			internal TypeSystemConvertVisitor convertVisitor;
+			internal bool isAttributeArgument;
+			
+			protected override ConstantExpression VisitChildren(AstNode node, object data)
+			{
+				return null;
+			}
+			
+			public override ConstantExpression VisitNullReferenceExpression(NullReferenceExpression nullReferenceExpression, object data)
+			{
+				return new PrimitiveConstantExpression(KnownTypeReference.Object, null);
+			}
+			
+			public override ConstantExpression VisitPrimitiveExpression(PrimitiveExpression primitiveExpression, object data)
+			{
+				TypeCode typeCode = Type.GetTypeCode(primitiveExpression.Value.GetType());
+				return new PrimitiveConstantExpression(typeCode.ToTypeReference(), primitiveExpression.Value);
+			}
+			
+			IList<ITypeReference> ConvertTypeArguments(AstNodeCollection<AstType> types)
+			{
+				int count = types.Count;
+				if (count == 0)
+					return null;
+				ITypeReference[] result = new ITypeReference[count];
+				int pos = 0;
+				foreach (AstType type in types) {
+					result[pos++] = convertVisitor.ConvertType(type);
+				}
+				return result;
+			}
+			
+			public override ConstantExpression VisitIdentifierExpression(IdentifierExpression identifierExpression, object data)
+			{
+				return new ConstantIdentifierReference(identifierExpression.Identifier, ConvertTypeArguments(identifierExpression.TypeArguments));
+			}
+			
+			public override ConstantExpression VisitMemberReferenceExpression(MemberReferenceExpression memberReferenceExpression, object data)
+			{
+				TypeReferenceExpression tre = memberReferenceExpression.Target as TypeReferenceExpression;
+				if (tre != null) {
+					// handle "int.MaxValue"
+					return new ConstantMemberReference(
+						convertVisitor.ConvertType(tre.Type),
+						memberReferenceExpression.MemberName,
+						ConvertTypeArguments(memberReferenceExpression.TypeArguments));
+				}
+				ConstantExpression v = memberReferenceExpression.Target.AcceptVisitor(this, data);
+				if (v == null)
+					return null;
+				return new ConstantMemberReference(
+					v, memberReferenceExpression.MemberName,
+					ConvertTypeArguments(memberReferenceExpression.TypeArguments));
+			}
+			
+			public override ConstantExpression VisitParenthesizedExpression(ParenthesizedExpression parenthesizedExpression, object data)
+			{
+				return parenthesizedExpression.Expression.AcceptVisitor(this, data);
+			}
+			
+			public override ConstantExpression VisitCastExpression(CastExpression castExpression, object data)
+			{
+				ConstantExpression v = castExpression.Expression.AcceptVisitor(this, data);
+				if (v == null)
+					return null;
+				return new ConstantCast(convertVisitor.ConvertType(castExpression.Type), v);
+			}
+			
+			public override ConstantExpression VisitCheckedExpression(CheckedExpression checkedExpression, object data)
+			{
+				ConstantExpression v = checkedExpression.Expression.AcceptVisitor(this, data);
+				if (v != null)
+					return new ConstantCheckedExpression(true, v);
+				else
+					return null;
+			}
+			
+			public override ConstantExpression VisitUncheckedExpression(UncheckedExpression uncheckedExpression, object data)
+			{
+				ConstantExpression v = uncheckedExpression.Expression.AcceptVisitor(this, data);
+				if (v != null)
+					return new ConstantCheckedExpression(false, v);
+				else
+					return null;
+			}
+			
+			public override ConstantExpression VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
+			{
+				return new ConstantDefaultValue(convertVisitor.ConvertType(defaultValueExpression.Type));
+			}
+			
+			public override ConstantExpression VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data)
+			{
+				ConstantExpression v = unaryOperatorExpression.Expression.AcceptVisitor(this, data);
+				if (v == null)
+					return null;
+				switch (unaryOperatorExpression.Operator) {
+					case UnaryOperatorType.Not:
+					case UnaryOperatorType.BitNot:
+					case UnaryOperatorType.Minus:
+					case UnaryOperatorType.Plus:
+						return new ConstantUnaryOperator(unaryOperatorExpression.Operator, v);
+					default:
+						return null;
+				}
+			}
+			
+			public override ConstantExpression VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data)
+			{
+				ConstantExpression left = binaryOperatorExpression.Left.AcceptVisitor(this, data);
+				ConstantExpression right = binaryOperatorExpression.Right.AcceptVisitor(this, data);
+				if (left == null || right == null)
+					return null;
+				return new ConstantBinaryOperator(left, binaryOperatorExpression.Operator, right);
+			}
+			
+			static readonly GetClassTypeReference systemType = new GetClassTypeReference("System", "Type", 0);
+			
+			public override ConstantExpression VisitTypeOfExpression(TypeOfExpression typeOfExpression, object data)
+			{
+				if (isAttributeArgument) {
+					return new PrimitiveConstantExpression(systemType, convertVisitor.ConvertType(typeOfExpression.Type));
+				} else {
+					return null;
+				}
+			}
+			
+			public override ConstantExpression VisitArrayCreateExpression(ArrayCreateExpression arrayObjectCreateExpression, object data)
+			{
+				var initializer = arrayObjectCreateExpression.Initializer;
+				if (isAttributeArgument && !initializer.IsNull) {
+					ITypeReference type;
+					if (arrayObjectCreateExpression.Type.IsNull)
+						type = null;
+					else
+						type = convertVisitor.ConvertType(arrayObjectCreateExpression.Type);
+					ConstantExpression[] elements = new ConstantExpression[initializer.Elements.Count];
+					int pos = 0;
+					foreach (Expression expr in initializer.Elements) {
+						ConstantExpression c = expr.AcceptVisitor(this, data);
+						if (c == null)
+							return null;
+						elements[pos++] = c;
+					}
+					return new ConstantArrayCreation(type, elements);
+				} else {
+					return null;
+				}
+			}
 		}
 		#endregion
 		
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/anonymous.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/anonymous.cs
index 71503b8da..9bf488ce0 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/anonymous.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/anonymous.cs
@@ -1186,7 +1186,7 @@ namespace Mono.CSharp {
 		public static void Error_AddressOfCapturedVar (ResolveContext ec, IVariableReference var, Location loc)
 		{
 			ec.Report.Error (1686, loc,
-				"Local variable or parameter `{0}' cannot have their address taken and be used inside an anonymous method or lambda expression",
+				"Local variable or parameter `{0}' cannot have their address taken and be used inside an anonymous method, lambda expression or query expression",
 				var.Name);
 		}
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/argument.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/argument.cs
index 4acd366f7..050644f06 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/argument.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/argument.cs
@@ -128,9 +128,6 @@ namespace Mono.CSharp
 
 		public void Resolve (ResolveContext ec)
 		{
-			if (Expr == EmptyExpression.Null)
-				return;
-
 //			using (ec.With (ResolveContext.Options.DoFlowAnalysis, true)) {
 				// Verify that the argument is readable
 				if (ArgType != AType.Out)
@@ -141,7 +138,7 @@ namespace Mono.CSharp
 					Expr = Expr.ResolveLValue (ec, EmptyExpression.OutAccess);
 
 				if (Expr == null)
-					Expr = EmptyExpression.Null;
+					Expr = ErrorExpression.Instance;
 //			}
 		}
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assembly.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assembly.cs
index 153934000..afae0c57a 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assembly.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assembly.cs
@@ -875,7 +875,7 @@ namespace Mono.CSharp
 				string main_class = Compiler.Settings.MainClass;
 				if (main_class != null) {
 					// TODO: Handle dotted names
-					var texpr = module.GlobalRootNamespace.LookupType (module, main_class, 0, Location.Null);
+					var texpr = module.GlobalRootNamespace.LookupType (module, main_class, 0, LookupMode.Probing, Location.Null);
 					if (texpr == null) {
 						Report.Error (1555, "Could not find `{0}' specified for Main method", main_class);
 						return;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assign.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assign.cs
index 1c7d0ec3f..6fd2a7a03 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assign.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/assign.cs
@@ -377,7 +377,7 @@ namespace Mono.CSharp {
 #endif
 		protected virtual Expression ResolveConversions (ResolveContext ec)
 		{
-			source = Convert.ImplicitConversionRequired (ec, source, target.Type, loc);
+			source = Convert.ImplicitConversionRequired (ec, source, target.Type, source.Location);
 			if (source == null)
 				return null;
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/attribute.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/attribute.cs
index f3ec19485..bfce7f92b 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/attribute.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/attribute.cs
@@ -21,10 +21,12 @@ using System.IO;
 
 #if STATIC
 using SecurityType = System.Collections.Generic.List<IKVM.Reflection.Emit.CustomAttributeBuilder>;
+using BadImageFormat = IKVM.Reflection.BadImageFormatException;
 using IKVM.Reflection;
 using IKVM.Reflection.Emit;
 #else
 using SecurityType = System.Collections.Generic.Dictionary<System.Security.Permissions.SecurityAction, System.Security.PermissionSet>;
+using BadImageFormat = System.BadImageFormatException;
 using System.Reflection;
 using System.Reflection.Emit;
 #endif
@@ -245,15 +247,6 @@ namespace Mono.CSharp {
 			}
 		}
 
-		TypeSpec ResolvePossibleAttributeType (ATypeNameExpression expr)
-		{
-			TypeExpr te = expr.ResolveAsType (context);
-			if (te == null)
-				return null;
-
-			return te.Type;
-		}
-
 		/// <summary>
 		///   Tries to resolve the type of the attribute. Flags an error if it can't, and complain is true.
 		/// </summary>
@@ -271,7 +264,7 @@ namespace Mono.CSharp {
 			// print on success
 
 			try {
-				t1 = ResolvePossibleAttributeType (expression);
+				t1 = expression.ResolveAsType (context);
 				if (t1 != null)
 					t1_is_attr = t1.IsAttribute;
 
@@ -283,7 +276,7 @@ namespace Mono.CSharp {
 					expanded = (ATypeNameExpression) expression.Clone (null);
 					expanded.Name += "Attribute";
 
-					t2 = ResolvePossibleAttributeType (expanded);
+					t2 = expanded.ResolveAsType (context);
 					if (t2 != null)
 						t2_is_attr = t2.IsAttribute;
 				}
@@ -659,7 +652,7 @@ namespace Mono.CSharp {
 				// But because a lot of attribute class code must be rewritten will be better to wait...
 				Resolve ();
 
-			if (resolve_error)
+			if (resolve_error || PosArguments.Count != 1 || !(PosArguments [0].Expr is Constant))
 				return null;
 
 			return ((Constant) PosArguments [0].Expr).GetValue () as string;
@@ -961,11 +954,12 @@ namespace Mono.CSharp {
 						var pt = param_types[j];
 						var arg_expr = PosArguments[j].Expr;
 						if (j == 0) {
-							if (Type == predefined.IndexerName || Type == predefined.Conditional) {
-								string v = ((StringConstant) arg_expr).Value;
+							if ((Type == predefined.IndexerName || Type == predefined.Conditional) && arg_expr is Constant) {
+								string v = ((Constant) arg_expr).GetValue () as string;
 								if (!Tokenizer.IsValidIdentifier (v) || Tokenizer.IsKeyword (v)) {
 									context.Module.Compiler.Report.Error (633, arg_expr.Location,
 										"The argument to the `{0}' attribute must be a valid identifier", GetSignatureForError ());
+									return;
 								}
 							} else if (Type == predefined.Guid) {
 								try {
@@ -989,7 +983,7 @@ namespace Mono.CSharp {
 									}
 								}
 							} else if (Type == predefined.DllImport) {
-								if (PosArguments.Count == 1) {
+								if (PosArguments.Count == 1 && PosArguments[0].Expr is Constant) {
 									var value = ((Constant) PosArguments[0].Expr).GetValue () as string;
 									if (string.IsNullOrEmpty (value))
 										Error_AttributeEmitError ("DllName cannot be empty");
@@ -1028,6 +1022,9 @@ namespace Mono.CSharp {
 				foreach (Attributable target in targets)
 					target.ApplyAttributeBuilder (this, ctor, cdata, predefined);
 			} catch (Exception e) {
+				if (e is BadImageFormat && Report.Errors > 0)
+					return;
+
 				Error_AttributeEmitError (e.Message);
 				return;
 			}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cfold.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cfold.cs
index 31297fa0c..1659dfe3a 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cfold.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cfold.cs
@@ -467,7 +467,8 @@ namespace Mono.CSharp {
 				}
 
 				if (left is NullLiteral && right is NullLiteral) {
-					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+					lifted_int.ResolveAsType (ec);
 					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 				}
 
@@ -563,7 +564,8 @@ namespace Mono.CSharp {
 				
 			case Binary.Operator.Multiply:
 				if (left is NullLiteral && right is NullLiteral) {
-					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+					lifted_int.ResolveAsType (ec);
 					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 				}
 
@@ -658,7 +660,8 @@ namespace Mono.CSharp {
 
 			case Binary.Operator.Division:
 				if (left is NullLiteral && right is NullLiteral) {
-					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+					lifted_int.ResolveAsType (ec);
 					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 				}
 
@@ -757,7 +760,8 @@ namespace Mono.CSharp {
 				
 			case Binary.Operator.Modulus:
 				if (left is NullLiteral && right is NullLiteral) {
-					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+					lifted_int.ResolveAsType (ec);
 					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 				}
 
@@ -846,7 +850,8 @@ namespace Mono.CSharp {
 				//
 			case Binary.Operator.LeftShift:
 				if (left is NullLiteral && right is NullLiteral) {
-					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+					lifted_int.ResolveAsType (ec);
 					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 				}
 
@@ -882,7 +887,8 @@ namespace Mono.CSharp {
 				//
 			case Binary.Operator.RightShift:
 				if (left is NullLiteral && right is NullLiteral) {
-					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+					var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+					lifted_int.ResolveAsType (ec);
 					return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 				}
 
@@ -913,7 +919,7 @@ namespace Mono.CSharp {
 				break;
 
 			case Binary.Operator.Equality:
-				if (TypeManager.IsReferenceType (lt) && TypeManager.IsReferenceType (rt) ||
+				if (TypeSpec.IsReferenceType (lt) && TypeSpec.IsReferenceType (rt) ||
 					(left is Nullable.LiftedNull && right.IsNull) ||
 					(right is Nullable.LiftedNull && left.IsNull)) {
 					if (left.IsNull || right.IsNull) {
@@ -957,7 +963,7 @@ namespace Mono.CSharp {
 				return new BoolConstant (ec.BuiltinTypes, bool_res, left.Location);
 
 			case Binary.Operator.Inequality:
-				if (TypeManager.IsReferenceType (lt) && TypeManager.IsReferenceType (rt) ||
+				if (TypeSpec.IsReferenceType (lt) && TypeSpec.IsReferenceType (rt) ||
 					(left is Nullable.LiftedNull && right.IsNull) ||
 					(right is Nullable.LiftedNull && left.IsNull)) {
 					if (left.IsNull || right.IsNull) {
@@ -1003,7 +1009,8 @@ namespace Mono.CSharp {
 			case Binary.Operator.LessThan:
 				if (right is NullLiteral) {
 					if (left is NullLiteral) {
-						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+						lifted_int.ResolveAsType (ec);
 						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 					}
 
@@ -1042,7 +1049,8 @@ namespace Mono.CSharp {
 			case Binary.Operator.GreaterThan:
 				if (right is NullLiteral) {
 					if (left is NullLiteral) {
-						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+						lifted_int.ResolveAsType (ec);
 						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 					}
 
@@ -1081,7 +1089,8 @@ namespace Mono.CSharp {
 			case Binary.Operator.GreaterThanOrEqual:
 				if (right is NullLiteral) {
 					if (left is NullLiteral) {
-						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+						lifted_int.ResolveAsType (ec);
 						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 					}
 
@@ -1120,7 +1129,8 @@ namespace Mono.CSharp {
 			case Binary.Operator.LessThanOrEqual:
 				if (right is NullLiteral) {
 					if (left is NullLiteral) {
-						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc).ResolveAsType (ec);
+						var lifted_int = new Nullable.NullableType (ec.BuiltinTypes.Int, loc);
+						lifted_int.ResolveAsType (ec);
 						return (Constant) new Nullable.LiftedBinaryOperator (oper, lifted_int, right, loc).Resolve (ec);
 					}
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/class.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/class.cs
index 446d88c5c..83fbea0b3 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/class.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/class.cs
@@ -78,10 +78,6 @@ namespace Mono.CSharp
 				get { return tc; }
 			}
 
-			public bool HasUnresolvedConstraints {
-				get { return true; }
-			}
-
 			public bool IsObsolete {
 				get { return tc.IsObsolete; }
 			}
@@ -113,7 +109,7 @@ namespace Mono.CSharp
 				return tc.Parent.LookupNamespaceAlias (name);
 			}
 
-			public FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
+			public FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 			{
 				if (arity == 0) {
 					TypeParameter[] tp = CurrentTypeParameters;
@@ -124,7 +120,7 @@ namespace Mono.CSharp
 					}
 				}
 
-				return tc.Parent.LookupNamespaceOrType (name, arity, loc, ignore_cs0104);
+				return tc.Parent.LookupNamespaceOrType (name, arity, mode, loc);
 			}
 
 			#endregion
@@ -204,8 +200,8 @@ namespace Mono.CSharp
 		// from classes from the arraylist `type_bases' 
 		//
 		protected TypeSpec base_type;
-		protected TypeExpr base_type_expr;
-		protected TypeExpr[] iface_exprs;
+		protected FullNamedExpression base_type_expr;	// TODO: It's temporary variable
+		protected TypeSpec[] iface_exprs;
 
 		protected List<FullNamedExpression> type_bases;
 
@@ -904,54 +900,54 @@ namespace Mono.CSharp
 		///   The @base_class argument is set to the base object or null
 		///   if this is `System.Object'. 
 		/// </summary>
-		protected virtual TypeExpr[] ResolveBaseTypes (out TypeExpr base_class)
+		protected virtual TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
 			base_class = null;
 			if (type_bases == null)
 				return null;
 
 			int count = type_bases.Count;
-			TypeExpr [] ifaces = null;
+			TypeSpec[] ifaces = null;
 			var base_context = new BaseContext (this);
 			for (int i = 0, j = 0; i < count; i++){
 				FullNamedExpression fne = type_bases [i];
 
-				TypeExpr fne_resolved = fne.ResolveAsType (base_context);
+				var fne_resolved = fne.ResolveAsType (base_context);
 				if (fne_resolved == null)
 					continue;
 
-				if (i == 0 && Kind == MemberKind.Class && !fne_resolved.Type.IsInterface) {
-					if (fne_resolved.Type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
+				if (i == 0 && Kind == MemberKind.Class && !fne_resolved.IsInterface) {
+					if (fne_resolved.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
 						Report.Error (1965, Location, "Class `{0}' cannot derive from the dynamic type",
 							GetSignatureForError ());
 
 						continue;
 					}
 					
-					base_type = fne_resolved.Type;
-					base_class = fne_resolved;
+					base_type = fne_resolved;
+					base_class = fne;
 					continue;
 				}
 
 				if (ifaces == null)
-					ifaces = new TypeExpr [count - i];
+					ifaces = new TypeSpec [count - i];
 
-				if (fne_resolved.Type.IsInterface) {
+				if (fne_resolved.IsInterface) {
 					for (int ii = 0; ii < j; ++ii) {
-						if (fne_resolved.Type == ifaces [ii].Type) {
+						if (fne_resolved == ifaces [ii]) {
 							Report.Error (528, Location, "`{0}' is already listed in interface list",
 								fne_resolved.GetSignatureForError ());
 							break;
 						}
 					}
 
-					if (Kind == MemberKind.Interface && !IsAccessibleAs (fne_resolved.Type)) {
+					if (Kind == MemberKind.Interface && !IsAccessibleAs (fne_resolved)) {
 						Report.Error (61, fne.Location,
 							"Inconsistent accessibility: base interface `{0}' is less accessible than interface `{1}'",
 							fne_resolved.GetSignatureForError (), GetSignatureForError ());
 					}
 				} else {
-					Report.SymbolRelatedToPreviousError (fne_resolved.Type);
+					Report.SymbolRelatedToPreviousError (fne_resolved);
 					if (Kind != MemberKind.Class) {
 						Report.Error (527, fne.Location, "Type `{0}' in interface list is not an interface", fne_resolved.GetSignatureForError ());
 					} else if (base_class != null)
@@ -969,31 +965,31 @@ namespace Mono.CSharp
 			return ifaces;
 		}
 
-		TypeExpr[] GetNormalPartialBases ()
+		TypeSpec[] GetNormalPartialBases ()
 		{
-			var ifaces = new List<TypeExpr> (0);
+			var ifaces = new List<TypeSpec> (0);
 			if (iface_exprs != null)
 				ifaces.AddRange (iface_exprs);
 
 			foreach (TypeContainer part in partial_parts) {
-				TypeExpr new_base_class;
-				TypeExpr[] new_ifaces = part.ResolveBaseTypes (out new_base_class);
+				FullNamedExpression new_base_class;
+				var new_ifaces = part.ResolveBaseTypes (out new_base_class);
 				if (new_base_class != null) {
-					if (base_type_expr != null && new_base_class.Type != base_type) {
+					if (base_type_expr != null && part.base_type != base_type) {
 						Report.SymbolRelatedToPreviousError (new_base_class.Location, "");
 						Report.Error (263, part.Location,
 							"Partial declarations of `{0}' must not specify different base classes",
 							part.GetSignatureForError ());
 					} else {
 						base_type_expr = new_base_class;
-						base_type = base_type_expr.Type;
+						base_type = part.base_type;
 					}
 				}
 
 				if (new_ifaces == null)
 					continue;
 
-				foreach (TypeExpr iface in new_ifaces) {
+				foreach (var iface in new_ifaces) {
 					if (ifaces.Contains (iface))
 						continue;
 
@@ -1152,16 +1148,19 @@ namespace Mono.CSharp
 
 				GenericMethod generic_method;
 				MemberName member_name;
+				TypeArguments targs = null;
 				if (method.IsGeneric) {
 					//
 					// Copy all base generic method type parameters info
 					//
 					var hoisted_tparams = method.GenericDefinition.TypeParameters;
-					var targs = new TypeArguments ();
 					var type_params = new TypeParameter[hoisted_tparams.Length];
+					targs = new TypeArguments ();
+					targs.Arguments = new TypeSpec[type_params.Length];
 					for (int i = 0; i < type_params.Length; ++i) {
 						var tp = hoisted_tparams[i];
 						targs.Add (new TypeParameterName (tp.Name, null, Location));
+						targs.Arguments[i] = tp;
 						type_params[i] = new TypeParameter (tp, this, null, new MemberName (tp.Name), null);
 					}
 
@@ -1182,6 +1181,8 @@ namespace Mono.CSharp
 
 				var mg = MethodGroupExpr.CreatePredefined (method, method.DeclaringType, Location);
 				mg.InstanceExpression = new BaseThis (method.DeclaringType, Location);
+				if (targs != null)
+					mg.SetTypeArguments (rc, targs);
 
 				// Get all the method parameters and pass them as arguments
 				var real_base_call = new Invocation (mg, block.GetAllParametersArguments ());
@@ -1229,30 +1230,14 @@ namespace Mono.CSharp
 			}
 
 			if (iface_exprs != null) {
-				foreach (TypeExpr iface in iface_exprs) {
+				foreach (var iface_type in iface_exprs) {
 					// Prevents a crash, the interface might not have been resolved: 442144
-					if (iface == null)
+					if (iface_type == null)
 						continue;
 					
-					var iface_type = iface.Type;
-
 					if (!spec.AddInterface (iface_type))
 						continue;
 
-					if (iface_type.IsGeneric && spec.Interfaces != null) {
-						foreach (var prev_iface in iface_exprs) {
-							if (prev_iface == iface)
-								break;
-
-							if (!TypeSpecComparer.Unify.IsEqual (iface_type, prev_iface.Type))
-								continue;
-
-							Report.Error (695, Location,
-								"`{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions",
-								GetSignatureForError (), prev_iface.GetSignatureForError (), iface_type.GetSignatureForError ());
-						}
-					}
-
 					TypeBuilder.AddInterfaceImplementation (iface_type.GetMetaInfo ());
 
 					// Ensure the base is always setup
@@ -1512,20 +1497,20 @@ namespace Mono.CSharp
 
 			InTransit = tc;
 
-			if (base_type_expr != null) {
+			if (base_type != null) {
 				var ptc = base_type.MemberDefinition as TypeContainer;
 				if (ptc != null && ptc.CheckRecursiveDefinition (this) != null)
 					return base_type;
 			}
 
 			if (iface_exprs != null) {
-				foreach (TypeExpr iface in iface_exprs) {
+				foreach (var iface in iface_exprs) {
 					// the interface might not have been resolved, prevents a crash, see #442144
 					if (iface == null)
 						continue;
-					var ptc = iface.Type.MemberDefinition as Interface;
+					var ptc = iface.MemberDefinition as Interface;
 					if (ptc != null && ptc.CheckRecursiveDefinition (this) != null)
-						return iface.Type;
+						return iface;
 				}
 			}
 
@@ -1558,12 +1543,10 @@ namespace Mono.CSharp
 		protected virtual bool DoDefineMembers ()
 		{
 			if (iface_exprs != null) {
-				foreach (TypeExpr iface in iface_exprs) {
-					if (iface == null)
+				foreach (var iface_type in iface_exprs) {
+					if (iface_type == null)
 						continue;
 
-					var iface_type = iface.Type;
-
 					// Ensure the base is always setup
 					var compiled_iface = iface_type.MemberDefinition as Interface;
 					if (compiled_iface != null)
@@ -1574,33 +1557,51 @@ namespace Mono.CSharp
 
 					ObsoleteAttribute oa = iface_type.GetAttributeObsolete ();
 					if (oa != null && !IsObsolete)
-						AttributeTester.Report_ObsoleteMessage (oa, iface.GetSignatureForError (), Location, Report);
+						AttributeTester.Report_ObsoleteMessage (oa, iface_type.GetSignatureForError (), Location, Report);
 
-					GenericTypeExpr ct = iface as GenericTypeExpr;
-					if (ct != null) {
+					if (iface_type.Arity > 0) {
 						// TODO: passing `this' is wrong, should be base type iface instead
-						TypeManager.CheckTypeVariance (ct.Type, Variance.Covariant, this);
+						TypeManager.CheckTypeVariance (iface_type, Variance.Covariant, this);
 
-						ct.CheckConstraints (this);
-
-						if (ct.HasDynamicArguments () && !IsCompilerGenerated) {
-							Report.Error (1966, iface.Location,
+						if (((InflatedTypeSpec) iface_type).HasDynamicArgument () && !IsCompilerGenerated) {
+							Report.Error (1966, Location,
 								"`{0}': cannot implement a dynamic interface `{1}'",
-								GetSignatureForError (), iface.GetSignatureForError ());
+								GetSignatureForError (), iface_type.GetSignatureForError ());
 							return false;
 						}
+
+						if (spec.Interfaces != null) {
+							foreach (var prev_iface in iface_exprs) {
+								if (prev_iface == iface_type)
+									break;
+
+								if (!TypeSpecComparer.Unify.IsEqual (iface_type, prev_iface))
+									continue;
+
+								Report.Error (695, Location,
+									"`{0}' cannot implement both `{1}' and `{2}' because they may unify for some type parameter substitutions",
+									GetSignatureForError (), prev_iface.GetSignatureForError (), iface_type.GetSignatureForError ());
+							}
+						}
 					}
 				}
 			}
 
 			if (base_type != null) {
-				ObsoleteAttribute obsolete_attr = base_type.GetAttributeObsolete ();
-				if (obsolete_attr != null && !IsObsolete)
-					AttributeTester.Report_ObsoleteMessage (obsolete_attr, base_type.GetSignatureForError (), Location, Report);
-
-				var ct = base_type_expr as GenericTypeExpr;
-				if (ct != null)
-					ct.CheckConstraints (this);
+				//
+				// Run checks skipped during DefineType (e.g FullNamedExpression::ResolveAsType)
+				//
+				if (base_type_expr != null) {
+					ObsoleteAttribute obsolete_attr = base_type.GetAttributeObsolete ();
+					if (obsolete_attr != null && !IsObsolete)
+						AttributeTester.Report_ObsoleteMessage (obsolete_attr, base_type.GetSignatureForError (), base_type_expr.Location, Report);
+
+					if (IsGeneric && base_type.IsAttribute) {
+						Report.Error (698, base_type_expr.Location,
+							"A generic type cannot derive from `{0}' because it is an attribute class",
+							base_type.GetSignatureForError ());
+					}
+				}
 
 				if (base_type.Interfaces != null) {
 					foreach (var iface in base_type.Interfaces)
@@ -1619,12 +1620,6 @@ namespace Mono.CSharp
 				}
 			}
 
-			if (type_params != null) {
-				foreach (var tp in type_params) {
-					tp.CheckGenericConstraints ();
-				}
-			}
-
 			DefineContainerMembers (constants);
 			DefineContainerMembers (fields);
 
@@ -1766,6 +1761,9 @@ namespace Mono.CSharp
 				if ((mc.ModFlags & Modifiers.AccessibilityMask) != Modifiers.PRIVATE)
 					continue;
 
+				if ((mc.ModFlags & Modifiers.PARTIAL) != 0)
+					continue;
+
 				if (!mc.IsUsed && (mc.caching_flags & Flags.Excluded) == 0) {
 					Report.Warning (169, 3, mc.Location, "The private {0} `{1}' is never used", member_type, mc.GetSignatureForError ());
 				}
@@ -1804,14 +1802,14 @@ namespace Mono.CSharp
 							continue;
 						}
 						
+						if ((f.caching_flags & Flags.IsAssigned) != 0)
+							continue;
+
 						//
 						// Only report 649 on level 4
 						//
 						if (Report.WarningLevel < 4)
 							continue;
-						
-						if ((f.caching_flags & Flags.IsAssigned) != 0)
-							continue;
 
 						//
 						// Don't be pendatic over serializable attributes
@@ -1820,8 +1818,24 @@ namespace Mono.CSharp
 							continue;
 						
 						Constant c = New.Constantify (f.MemberType, f.Location);
-						Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value `{1}'",
-							f.GetSignatureForError (), c == null ? "null" : c.GetValueAsLiteral ());
+						string value;
+						if (c != null) {
+							value = c.GetValueAsLiteral ();
+						} else if (TypeSpec.IsReferenceType (f.MemberType)) {
+							value = "null";
+						} else {
+							// Ignore this warning for struct value fields (they are always initialized)
+							if (f.MemberType.IsStruct)
+								continue;
+
+							value = null;
+						}
+
+						if (value != null)
+							value = " `" + value + "'";
+
+						Report.Warning (649, 4, f.Location, "Field `{0}' is never assigned to, and will always have its default value{1}",
+							f.GetSignatureForError (), value);
 					}
 				}
 			}
@@ -1831,7 +1845,8 @@ namespace Mono.CSharp
 		{
 			if (!IsTopLevel) {
 				MemberSpec candidate;
-				var conflict_symbol = MemberCache.FindBaseMember (this, out candidate);
+				bool overrides = false;
+				var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
 				if (conflict_symbol == null && candidate == null) {
 					if ((ModFlags & Modifiers.NEW) != 0)
 						Report.Warning (109, 4, Location, "The member `{0}' does not hide an inherited member. The new keyword is not required",
@@ -1848,13 +1863,31 @@ namespace Mono.CSharp
 				}
 			}
 
+			// Run constraints check on all possible generic types
+			if ((ModFlags & Modifiers.COMPILER_GENERATED) == 0) {
+				if (base_type != null && base_type_expr != null) {
+					ConstraintChecker.Check (this, base_type, base_type_expr.Location);
+				}
+
+				if (iface_exprs != null) {
+					foreach (var iface_type in iface_exprs) {
+						if (iface_type == null)
+							continue;
+
+						ConstraintChecker.Check (this, iface_type, Location);	// TODO: Location is wrong
+					}
+				}
+			}
+
 			if (all_tp_builders != null) {
 				int current_starts_index = CurrentTypeParametersStartIndex;
 				for (int i = 0; i < all_tp_builders.Length; i++) {
 					if (i < current_starts_index) {
 						TypeParameters[i].EmitConstraints (all_tp_builders [i]);
 					} else {
-						CurrentTypeParameters [i - current_starts_index].Emit ();
+						var tp = CurrentTypeParameters [i - current_starts_index];
+						tp.CheckGenericConstraints (!IsObsolete);
+						tp.Emit ();
 					}
 				}
 			}
@@ -1963,7 +1996,7 @@ namespace Mono.CSharp
 			}
 
 			if (pending != null)
-				pending.VerifyPendingMethods (Report);
+				pending.VerifyPendingMethods ();
 
 			if (Report.Errors > 0)
 				return;
@@ -2187,10 +2220,10 @@ namespace Mono.CSharp
 		//
 		// Returns: Type or null if they type can not be found.
 		//
-		public override FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
+		public override FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 		{
 			FullNamedExpression e;
-			if (arity == 0 && Cache.TryGetValue (name, out e))
+			if (arity == 0 && Cache.TryGetValue (name, out e) && mode != LookupMode.IgnoreAccessibility)
 				return e;
 
 			e = null;
@@ -2207,14 +2240,14 @@ namespace Mono.CSharp
 			if (e == null) {
 				TypeSpec t = LookupNestedTypeInHierarchy (name, arity);
 
-				if (t != null)
+				if (t != null && (t.IsAccessible (this) || mode == LookupMode.IgnoreAccessibility))
 					e = new TypeExpression (t, Location.Null);
 				else if (Parent != null) {
-					e = Parent.LookupNamespaceOrType (name, arity, loc, ignore_cs0104);
+					e = Parent.LookupNamespaceOrType (name, arity, mode, loc);
 				} else {
 					int errors = Report.Errors;
 
-					e = NamespaceEntry.LookupNamespaceOrType (name, arity, loc, ignore_cs0104);
+					e = NamespaceEntry.LookupNamespaceOrType (name, arity, mode, loc);
 
 					if (errors != Report.Errors)
 						return e;
@@ -2222,7 +2255,7 @@ namespace Mono.CSharp
 			}
 
 			// TODO MemberCache: How to cache arity stuff ?
-			if (arity == 0)
+			if (arity == 0 && mode == LookupMode.Normal)
 				Cache[name] = e;
 
 			return e;
@@ -2245,15 +2278,7 @@ namespace Mono.CSharp
 			if (container == null)
 				return null;
 
-			var t = MemberCache.FindNestedType (container, name, arity);
-			if (t == null)
-				return null;
-
-			// FIXME: Breaks error reporting
-			if (!t.IsAccessible (this))
-				return null;
-
-			return t;
+			return MemberCache.FindNestedType (container, name, arity);
 		}
 
 		public void Mark_HasEquals ()
@@ -2601,9 +2626,9 @@ namespace Mono.CSharp
 			}
 		}
 
-		protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class)
+		protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
-			TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class);
+			var ifaces = base.ResolveBaseTypes (out base_class);
 
 			if (base_class == null) {
 				if (spec.BuiltinType != BuiltinTypeSpec.Type.Object)
@@ -2612,21 +2637,17 @@ namespace Mono.CSharp
 				if (base_type.IsGenericParameter){
 					Report.Error (689, base_class.Location, "`{0}': Cannot derive from type parameter `{1}'",
 						GetSignatureForError (), base_type.GetSignatureForError ());
-				} else if (IsGeneric && base_type.IsAttribute) {
-					Report.Error (698, base_class.Location,
-						"A generic type cannot derive from `{0}' because it is an attribute class",
-						base_class.GetSignatureForError ());
 				} else if (base_type.IsStatic) {
-					Report.SymbolRelatedToPreviousError (base_class.Type);
+					Report.SymbolRelatedToPreviousError (base_type);
 					Report.Error (709, Location, "`{0}': Cannot derive from static class `{1}'",
 						GetSignatureForError (), base_type.GetSignatureForError ());
 				} else if (base_type.IsSealed) {
-					Report.SymbolRelatedToPreviousError (base_class.Type);
+					Report.SymbolRelatedToPreviousError (base_type);
 					Report.Error (509, Location, "`{0}': cannot derive from sealed type `{1}'",
 						GetSignatureForError (), base_type.GetSignatureForError ());
-				} else if (PartialContainer.IsStatic && base_class.Type.BuiltinType != BuiltinTypeSpec.Type.Object) {
+				} else if (PartialContainer.IsStatic && base_type.BuiltinType != BuiltinTypeSpec.Type.Object) {
 					Report.Error (713, Location, "Static class `{0}' cannot derive from type `{1}'. Static classes must derive from object",
-						GetSignatureForError (), base_class.GetSignatureForError ());
+						GetSignatureForError (), base_type.GetSignatureForError ());
 				}
 
 				switch (base_type.BuiltinType) {
@@ -2652,8 +2673,8 @@ namespace Mono.CSharp
 			}
 
 			if (PartialContainer.IsStatic && ifaces != null) {
-				foreach (TypeExpr t in ifaces)
-					Report.SymbolRelatedToPreviousError (t.Type);
+				foreach (var t in ifaces)
+					Report.SymbolRelatedToPreviousError (t);
 				Report.Error (714, Location, "Static class `{0}' cannot implement interfaces", GetSignatureForError ());
 			}
 
@@ -2859,9 +2880,9 @@ namespace Mono.CSharp
 			return true;
 		}
 
-		protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class)
+		protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
-			TypeExpr[] ifaces = base.ResolveBaseTypes (out base_class);
+			var ifaces = base.ResolveBaseTypes (out base_class);
 			base_type = Compiler.BuiltinTypes.ValueType;
 			return ifaces;
 		}
@@ -2897,7 +2918,7 @@ namespace Mono.CSharp
 		/// <summary>
 		///   Modifiers allowed in a class declaration
 		/// </summary>
-		public const Modifiers AllowedModifiers =
+		const Modifiers AllowedModifiers =
 			Modifiers.NEW       |
 			Modifiers.PUBLIC    |
 			Modifiers.PROTECTED |
@@ -2958,12 +2979,12 @@ namespace Mono.CSharp
 
 			if (iface_exprs != null) {
 				foreach (var iface in iface_exprs) {
-					if (iface.Type.IsCLSCompliant ())
+					if (iface.IsCLSCompliant ())
 						continue;
 
-					Report.SymbolRelatedToPreviousError (iface.Type);
+					Report.SymbolRelatedToPreviousError (iface);
 					Report.Warning (3027, 1, Location, "`{0}' is not CLS-compliant because base interface `{1}' is not CLS-compliant",
-						GetSignatureForError (), TypeManager.CSharpName (iface.Type));
+						GetSignatureForError (), TypeManager.CSharpName (iface));
 				}
 			}
 
@@ -3065,7 +3086,8 @@ namespace Mono.CSharp
 				return true;
 
 			MemberSpec candidate;
-			var base_member = FindBaseMember (out candidate);
+			bool overrides = false;
+			var base_member = FindBaseMember (out candidate, ref overrides);
 
 			if ((ModFlags & Modifiers.OVERRIDE) != 0) {
 				if (base_member == null) {
@@ -3093,6 +3115,22 @@ namespace Mono.CSharp
 					return false;
 				}
 
+				//
+				// Handles ambiguous overrides
+				//
+				if (candidate != null) {
+					Report.SymbolRelatedToPreviousError (candidate);
+					Report.SymbolRelatedToPreviousError (base_member);
+
+					// Get member definition for error reporting
+					var m1 = MemberCache.GetMember (base_member.DeclaringType.GetDefinition (), base_member);
+					var m2 = MemberCache.GetMember (candidate.DeclaringType.GetDefinition (), candidate);
+
+					Report.Error (462, Location,
+						"`{0}' cannot override inherited members `{1}' and `{2}' because they have the same signature when used in type `{3}'",
+						GetSignatureForError (), m1.GetSignatureForError (), m2.GetSignatureForError (), Parent.GetSignatureForError ());
+				}
+
 				if (!CheckOverrideAgainstBase (base_member))
 					return false;
 
@@ -3140,7 +3178,7 @@ namespace Mono.CSharp
 					}
 				}
 
-				if (!IsInterface && base_member.IsAbstract && candidate == null) {
+				if (!IsInterface && base_member.IsAbstract && !overrides) {
 					Report.SymbolRelatedToPreviousError (base_member);
 					Report.Error (533, Location, "`{0}' hides inherited abstract member `{1}'",
 						GetSignatureForError (), base_member.GetSignatureForError ());
@@ -3249,8 +3287,8 @@ namespace Mono.CSharp
 			}
 
 			if (IsExplicitImpl) {
-				TypeExpr iface_texpr = MemberName.Left.GetTypeExpression ().ResolveAsType (Parent);
-				if (iface_texpr == null)
+				InterfaceType = MemberName.Left.GetTypeExpression ().ResolveAsType (Parent);
+				if (InterfaceType == null)
 					return false;
 
 				if ((ModFlags & Modifiers.PARTIAL) != 0) {
@@ -3258,8 +3296,6 @@ namespace Mono.CSharp
 						GetSignatureForError ());
 				}
 
-				InterfaceType = iface_texpr.Type;
-
 				if (!InterfaceType.IsInterface) {
 					Report.SymbolRelatedToPreviousError (InterfaceType);
 					Report.Error (538, Location, "The type `{0}' in explicit interface declaration is not an interface",
@@ -3377,9 +3413,9 @@ namespace Mono.CSharp
 		/// <summary>
 		/// Gets base method and its return type
 		/// </summary>
-		protected virtual MemberSpec FindBaseMember (out MemberSpec bestCandidate)
+		protected virtual MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
 		{
-			return MemberCache.FindBaseMember (this, out bestCandidate);
+			return MemberCache.FindBaseMember (this, out bestCandidate, ref overrides);
 		}
 
 		//
@@ -3578,17 +3614,8 @@ namespace Mono.CSharp
 			if (member_type != null)
 				throw new InternalErrorException ("Multi-resolve");
 
-			TypeExpr te = type_expr.ResolveAsType (this);
-			if (te == null)
-				return false;
-			
-			//
-			// Replace original type name, error reporting can use fully resolved name
-			//
-			type_expr = te;
-
-			member_type = te.Type;
-			return true;
+			member_type = type_expr.ResolveAsType (this);
+			return member_type != null;
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/codegen.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/codegen.cs
index e8900de8b..abd114d2f 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/codegen.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/codegen.cs
@@ -344,9 +344,6 @@ namespace Mono.CSharp
 
 		public void EmitArrayAddress (ArrayContainer ac)
 		{
-			if (ac.Element.IsGenericParameter)
-				ig.Emit (OpCodes.Readonly);
-
 			if (ac.Rank > 1) {
 				if (IsAnonymousStoreyMutateRequired)
 					ac = (ArrayContainer) ac.Mutate (CurrentAnonymousMethod.Storey.Mutator);
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/const.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/const.cs
index a66ebdd82..0ff7bf81f 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/const.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/const.cs
@@ -19,7 +19,7 @@ namespace Mono.CSharp {
 
 	public class Const : FieldBase
 	{
-		public const Modifiers AllowedModifiers =
+		const Modifiers AllowedModifiers =
 			Modifiers.NEW |
 			Modifiers.PUBLIC |
 			Modifiers.PROTECTED |
@@ -200,7 +200,7 @@ namespace Mono.CSharp {
 					c = field.ConvertInitializer (rc, c);
 
 				if (c == null) {
-					if (TypeManager.IsReferenceType (field.MemberType))
+					if (TypeSpec.IsReferenceType (field.MemberType))
 						Error_ConstantCanBeInitializedWithNullOnly (rc, field.MemberType, expr.Location, GetSignatureForError ());
 					else if (!(expr is Constant))
 						Error_ExpressionMustBeConstant (rc, expr.Location, GetSignatureForError ());
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/constant.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/constant.cs
index 1a815dad7..2848e46a7 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/constant.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/constant.cs
@@ -150,7 +150,7 @@ namespace Mono.CSharp {
 				if (t.IsNullableType)
 					return Nullable.LiftedNull.Create (t, loc);
 
-				if (TypeManager.IsReferenceType (t))
+				if (TypeSpec.IsReferenceType (t))
 					return new NullConstant (t, loc);
 			}
 
@@ -162,7 +162,7 @@ namespace Mono.CSharp {
 		{
 			Arguments args = new Arguments (2);
 			args.Add (new Argument (this));
-			args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+			args.Add (new Argument (new TypeOf (type, loc)));
 
 			return CreateExpressionFactoryCall (ec, "Constant", args);
 		}
@@ -2079,7 +2079,7 @@ namespace Mono.CSharp {
 			if (!IsLiteral && !Convert.ImplicitStandardConversionExists (this, targetType))
 				return null;
 
-			if (TypeManager.IsReferenceType (targetType))
+			if (TypeSpec.IsReferenceType (targetType))
 				return new NullConstant (targetType, loc);
 
 			if (targetType.IsNullableType)
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/context.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/context.cs
index ff84ce57f..01cad1f2e 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/context.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/context.cs
@@ -21,6 +21,13 @@ using System.Reflection.Emit;
 
 namespace Mono.CSharp
 {
+	public enum LookupMode
+	{
+		Normal = 0,
+		Probing = 1,
+		IgnoreAccessibility = 2
+	}
+
 	//
 	// Implemented by elements which can act as independent contexts
 	// during resolve phase. Used mostly for lookups.
@@ -48,12 +55,11 @@ namespace Mono.CSharp
 		bool IsObsolete { get; }
 		bool IsUnsafe { get; }
 		bool IsStatic { get; }
-		bool HasUnresolvedConstraints { get; }
 
 		string GetSignatureForError ();
 
 		IList<MethodSpec> LookupExtensionMethod (TypeSpec extensionType, string name, int arity, ref NamespaceContainer scope);
-		FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104);
+		FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc);
 		FullNamedExpression LookupNamespaceAlias (string name);
 	}
 
@@ -414,10 +420,6 @@ namespace Mono.CSharp
 			get { return (flags & Options.DoFlowAnalysis) != 0; }
 		}
 
-		public bool HasUnresolvedConstraints {
-			get { return false; }
-		}
-
 		public bool IsInProbingMode {
 			get {
 				return (flags & Options.ProbingMode) != 0;
@@ -520,9 +522,9 @@ namespace Mono.CSharp
 			return MemberContext.LookupExtensionMethod (extensionType, name, arity, ref scope);
 		}
 
-		public FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
+		public FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 		{
-			return MemberContext.LookupNamespaceOrType (name, arity, loc, ignore_cs0104);
+			return MemberContext.LookupNamespaceOrType (name, arity, mode, loc);
 		}
 
 		public FullNamedExpression LookupNamespaceAlias (string name)
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/convert.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/convert.cs
index 8a523a1ed..3283e58b3 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/convert.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/convert.cs
@@ -40,6 +40,12 @@ namespace Mono.CSharp {
 			if (array.Element == arg_type)
 				return true;
 
+			//
+			// Reject conversion from T[] to IList<U> even if T has U dependency
+			//
+			if (arg_type.IsGenericParameter)
+				return false;
+
 			if (isExplicit)
 				return ExplicitReferenceConversionExists (array.Element, arg_type);
 
@@ -160,12 +166,6 @@ namespace Mono.CSharp {
 		{
 			TypeSpec expr_type = expr.Type;
 
-			if (expr_type == null && expr.eclass == ExprClass.MethodGroup){
-				// if we are a method group, emit a warning
-
-				expr.Emit (null);
-			}
-
 			if (expr_type.Kind == MemberKind.TypeParameter)
 				return ImplicitTypeParameterConversion (expr, (TypeParameterSpec) expr.Type, target_type);
 
@@ -187,114 +187,154 @@ namespace Mono.CSharp {
 				return EmptyCast.Create (expr, target_type);
 			}
 
-			return ImplicitBoxingConversion (expr, expr_type, target_type);
+			return null;
 		}
 
 		//
-		// 6.1.6 Implicit reference conversions
+		// Implicit reference conversions
 		//
 		public static bool ImplicitReferenceConversionExists (TypeSpec expr_type, TypeSpec target_type)
 		{
+			// It's here only to speed things up
 			if (target_type.IsStruct)
 				return false;
 
-			// from the null type to any reference-type.
-			if (expr_type == InternalType.NullLiteral)
-				return true;
-
-			if (expr_type.IsGenericParameter)
+			switch (expr_type.Kind) {
+			case MemberKind.TypeParameter:
 				return ImplicitTypeParameterConversion (null, (TypeParameterSpec) expr_type, target_type) != null;
 
-			// This code is kind of mirrored inside ImplicitStandardConversionExists
-			// with the small distinction that we only probe there
-			//
-			// Always ensure that the code here and there is in sync
+			case MemberKind.Class:
+				//
+				// From any class-type to dynamic (+object to speed up common path)
+				//
+				if (target_type.BuiltinType == BuiltinTypeSpec.Type.Object || target_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+					return true;
 
-			// from any class-type S to any interface-type T.
-			if (target_type.IsInterface) {
-				if (expr_type.ImplementsInterface (target_type, true)){
-					return !TypeManager.IsValueType (expr_type);
-				}
-			}
+				if (target_type.IsClass) {
+					//
+					// Identity conversion, including dynamic erasure
+					//
+					if (TypeSpecComparer.IsEqual (expr_type, target_type))
+						return true;
 
-			//
-			// Implicit reference conversions (no-boxing) to object or dynamic
-			//
-			if (target_type.BuiltinType == BuiltinTypeSpec.Type.Object || target_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
-				switch (expr_type.Kind) {
-				case MemberKind.Class:
-				case MemberKind.Interface:
-				case MemberKind.Delegate:
-				case MemberKind.ArrayType:
-					return true;
+					//
+					// From any class-type S to any class-type T, provided S is derived from T
+					//
+					return TypeSpec.IsBaseClass (expr_type, target_type, true);
 				}
 
-				return expr_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic;
-			}
-
-			if (expr_type == target_type || TypeSpec.IsBaseClass (expr_type, target_type, true)) {
-				if (TypeManager.IsGenericParameter (expr_type))
-					return false;
+				//
+				// From any class-type S to any interface-type T, provided S implements T
+				//
+				if (target_type.IsInterface)
+					return expr_type.ImplementsInterface (target_type, true);
 
-				if (TypeManager.IsValueType (expr_type))
-					return false;
+				return false;
 
-				// Array type variance conversion
-				//if (target_type.IsArray != expr_type.IsArray)
-				//	return false;
+			case MemberKind.ArrayType:
+				//
+				// Identity array conversion
+				//
+				if (expr_type == target_type)
+					return true;
 
-				return true;
-			}
+				//
+				// From any array-type to System.Array
+				//
+				switch (target_type.BuiltinType) {
+				case BuiltinTypeSpec.Type.Array:
+				case BuiltinTypeSpec.Type.Object:
+				case BuiltinTypeSpec.Type.Dynamic:
+					return true;
+				}
 
-			var expr_type_array = expr_type as ArrayContainer;
-			if (expr_type_array != null) {
+				var expr_type_array = (ArrayContainer) expr_type;
 				var target_type_array = target_type as ArrayContainer;
-				// from an array-type S to an array-type of type T
+
+				//
+				// From an array-type S to an array-type of type T
+				//
 				if (target_type_array != null && expr_type_array.Rank == target_type_array.Rank) {
 
 					//
-					// Both SE and TE are reference-types
+					// Both SE and TE are reference-types. TE check is defered
+					// to ImplicitReferenceConversionExists
 					//
 					TypeSpec expr_element_type = expr_type_array.Element;
-					if (!TypeManager.IsReferenceType (expr_element_type))
-						return false;
-
-					TypeSpec target_element_type = target_type_array.Element;
-					if (!TypeManager.IsReferenceType (target_element_type))
+					if (!TypeSpec.IsReferenceType (expr_element_type))
 						return false;
 
 					//
 					// An implicit reference conversion exists from SE to TE
 					//
-					return ImplicitReferenceConversionExists (expr_element_type, target_element_type);
+					return ImplicitReferenceConversionExists (expr_element_type, target_type_array.Element);
 				}
 
-				// from an array-type to System.Array
-				if (target_type.BuiltinType == BuiltinTypeSpec.Type.Array)
+				//
+				// From any array-type to the interfaces it implements
+				//
+				if (target_type.IsInterface) {
+					if (expr_type.ImplementsInterface (target_type, false))
+						return true;
+
+					// from an array-type of type T to IList<T>
+					if (ArrayToIList (expr_type_array, target_type, false))
+						return true;
+				}
+
+				return false;
+
+			case MemberKind.Delegate:
+				//
+				// From any delegate-type to System.Delegate (and its base types)
+				//
+				switch (target_type.BuiltinType) {
+				case BuiltinTypeSpec.Type.Delegate:
+				case BuiltinTypeSpec.Type.MulticastDelegate:
+				case BuiltinTypeSpec.Type.Object:
+				case BuiltinTypeSpec.Type.Dynamic:
 					return true;
+				}
 
-				// from an array-type of type T to IList<T>
-				if (ArrayToIList (expr_type_array, target_type, false))
+				//
+				// Identity conversion, including dynamic erasure
+				//
+				if (TypeSpecComparer.IsEqual (expr_type, target_type))
 					return true;
 
-				return false;
-			}
+				//
+				// From any delegate-type to the interfaces it implements
+				// From any reference-type to an delegate type if is variance-convertible
+				//
+				return expr_type.ImplementsInterface (target_type, false) || TypeSpecComparer.Variant.IsEqual (expr_type, target_type);
 
-			if (TypeSpecComparer.IsEqual (expr_type, target_type))
-				return true;
+			case MemberKind.Interface:
+				//
+				// Identity conversion, including dynamic erasure
+				//
+				if (TypeSpecComparer.IsEqual (expr_type, target_type))
+					return true;
 
-			if (TypeSpecComparer.Variant.IsEqual (expr_type, target_type))
-				return true;
+				//
+				// From any interface type S to interface-type T
+				// From any reference-type to an interface if is variance-convertible
+				//
+				if (target_type.IsInterface)
+					return TypeSpecComparer.Variant.IsEqual (expr_type, target_type) || expr_type.ImplementsInterface (target_type, true);
 
-			// from any interface type S to interface-type T.
-			if (expr_type.IsInterface && target_type.IsInterface) {
-				return expr_type.ImplementsInterface (target_type, true);
+				return target_type.BuiltinType == BuiltinTypeSpec.Type.Object || target_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic;
 			}
 
-			// from any delegate type to System.Delegate
-			if (target_type.BuiltinType == BuiltinTypeSpec.Type.Delegate &&
-				(expr_type.BuiltinType == BuiltinTypeSpec.Type.Delegate || expr_type.IsDelegate))
-				return true;
+			//
+			// from the null literal to any reference-type.
+			//
+			if (expr_type == InternalType.NullLiteral) {
+				// Exlude internal compiler types
+				if (target_type.Kind == MemberKind.InternalCompilerType)
+					return target_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic;
+
+				return TypeSpec.IsReferenceType (target_type);
+			}
 
 			return false;
 		}
@@ -303,26 +343,18 @@ namespace Mono.CSharp {
 		{
 			switch (target_type.BuiltinType) {
 			//
-			// From any value-type to the type object.
+			// From any non-nullable-value-type to the type object and dynamic
 			//
 			case BuiltinTypeSpec.Type.Object:
 			case BuiltinTypeSpec.Type.Dynamic:
-				//
-				// A pointer type cannot be converted to object
-				//
-				if (expr_type.IsPointer)
-					return null;
-
-				if (!TypeManager.IsValueType (expr_type))
-					return null;
-
-				return expr == null ? EmptyExpression.Null : new BoxedCast (expr, target_type);
-
 			//
-			// From any value-type to the type System.ValueType.
+			// From any non-nullable-value-type to the type System.ValueType
 			//
 			case BuiltinTypeSpec.Type.ValueType:
-				if (!TypeManager.IsValueType (expr_type))
+				//
+				// No ned to check for nullable type as underlying type is always convertible
+				//
+				if (!TypeSpec.IsValueType (expr_type))
 					return null;
 
 				return expr == null ? EmptyExpression.Null : new BoxedCast (expr, target_type);
@@ -342,7 +374,7 @@ namespace Mono.CSharp {
 			// the underlying type to the reference type
 			//
 			if (expr_type.IsNullableType) {
-				if (!TypeManager.IsReferenceType (target_type))
+				if (!TypeSpec.IsReferenceType (target_type))
 					return null;
 
 				var res = ImplicitBoxingConversion (expr, Nullable.NullableInfo.GetUnderlyingType (expr_type), target_type);
@@ -355,27 +387,12 @@ namespace Mono.CSharp {
 				return res;
 			}
 
-			if (TypeSpec.IsBaseClass (expr_type, target_type, false)) {
-				//
-				// Don't box same type arguments
-				//
-				if (TypeManager.IsGenericParameter (expr_type) && expr_type != target_type)
-					return expr == null ? EmptyExpression.Null : new BoxedCast (expr, target_type);
-
-				return null;
-			}
-
-			// This code is kind of mirrored inside ImplicitStandardConversionExists
-			// with the small distinction that we only probe there
 			//
-			// Always ensure that the code here and there is in sync
-
-			// from any class-type S to any interface-type T.
-			if (target_type.IsInterface) {
-				if (expr_type.ImplementsInterface (target_type, true) &&
-					(TypeManager.IsGenericParameter (expr_type) || TypeManager.IsValueType (expr_type))) {
-					return expr == null ? EmptyExpression.Null : new BoxedCast (expr, target_type);
-				}
+			// A value type has a boxing conversion to an interface type I if it has a boxing conversion
+			// to an interface or delegate type I0 and I0 is variance-convertible to I
+			//
+			if (target_type.IsInterface && TypeSpec.IsValueType (expr_type) && expr_type.ImplementsInterface (target_type, true)) {
+				return expr == null ? EmptyExpression.Null : new BoxedCast (expr, target_type);
 			}
 
 			return null;
@@ -622,10 +639,9 @@ namespace Mono.CSharp {
 			return null;
 		}
 
-		/// <summary>
-		///  Same as ImplicitStandardConversionExists except that it also looks at
-		///  implicit user defined conversions - needed for overload resolution
-		/// </summary>
+		//
+		// Full version of implicit conversion
+		//
 		public static bool ImplicitConversionExists (ResolveContext ec, Expression expr, TypeSpec target_type)
 		{
 			if (ImplicitStandardConversionExists (expr, target_type))
@@ -656,47 +672,29 @@ namespace Mono.CSharp {
 			return ImplicitUserConversion (ec, expr, target_type, Location.Null) != null;
 		}
 
-		/// <summary>
-		///  Determines if a standard implicit conversion exists from
-		///  expr_type to target_type
-		///
-		/// </summary>
+		//
+		// Implicit standard conversion (only core conversions are used here)
+		//
 		public static bool ImplicitStandardConversionExists (Expression expr, TypeSpec target_type)
 		{
-			TypeSpec expr_type = expr.Type;
+			//
+			// Identity conversions
+			// Implicit numeric conversions
+			// Implicit nullable conversions
+			// Implicit reference conversions
+			// Boxing conversions
+			// Implicit constant expression conversions
+			// Implicit conversions involving type parameters
+			//
 
-			NullLiteral nl = expr as NullLiteral;
-			if (nl != null)
-				return nl.ConvertImplicitly (target_type) != null;
+			TypeSpec expr_type = expr.Type;
 
 			if (expr_type == target_type)
 				return true;
 
-			// Implicit dynamic conversion
-			if (expr_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
-				switch (target_type.Kind) {
-				case MemberKind.ArrayType:
-				case MemberKind.Class:
-				case MemberKind.Struct:
-				case MemberKind.Delegate:
-				case MemberKind.Enum:
-				case MemberKind.Interface:
-				case MemberKind.TypeParameter:
-					return true;
-				}
-
-				// dynamic to __arglist
-				if (target_type == InternalType.Arglist)
-					return true;
-
-				return false;
-			}
-
-			if (target_type.IsNullableType) {
+			if (target_type.IsNullableType)
 				return ImplicitNulableConversion (null, expr, target_type) != null;
-			}
 
-			// First numeric conversions
 			if (ImplicitNumericConversion (null, expr_type, target_type) != null)
 				return true;
 
@@ -768,17 +766,42 @@ namespace Mono.CSharp {
 				return i.IsZeroInteger;
 			}
 
+			// Implicit dynamic conversion
+			if (expr_type.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
+				switch (target_type.Kind) {
+				case MemberKind.ArrayType:
+				case MemberKind.Class:
+				case MemberKind.Struct:
+				case MemberKind.Delegate:
+				case MemberKind.Enum:
+				case MemberKind.Interface:
+				case MemberKind.TypeParameter:
+					return true;
+				}
+
+				// dynamic to __arglist
+				if (target_type == InternalType.Arglist)
+					return true;
+
+				return false;
+			}
+
 			//
-			// If `expr_type' implements `target_type' (which is an iface)
-			// see TryImplicitIntConversion
+			// In an unsafe context implicit conversions is extended to include
 			//
-			if (target_type.IsInterface && expr_type.ImplementsInterface (target_type, true))
-				return true;
-
-			if (target_type.IsPointer && expr_type.IsPointer && ((PointerContainer) target_type).Element.Kind == MemberKind.Void)
+			// From any pointer-type to the type void*
+			// From the null literal to any pointer-type.
+			//
+			// LAMESPEC: The specification claims this conversion is allowed in implicit conversion but
+			// in reality implicit standard conversion uses it
+			//
+			if (target_type.IsPointer && expr.Type.IsPointer && ((PointerContainer) target_type).Element.Kind == MemberKind.Void)
 				return true;
 
-			if (TypeSpecComparer.IsEqual (expr_type, target_type))
+			//
+			// Struct identity conversion, including dynamic erasure
+			//
+			if (expr_type.IsStruct && TypeSpecComparer.IsEqual (expr_type, target_type))
 				return true;
 
 			return false;
@@ -817,40 +840,42 @@ namespace Mono.CSharp {
 			return best;
 		}
 
-		/// <summary>
-		///  Finds "most encompassing type" according to the spec (13.4.2)
-		///  amongst the types in the given set
-		/// </summary>
+		//
+		// Finds the most encompassing type (type into which all other
+		// types can convert to) amongst the types in the given set
+		//
 		static TypeSpec FindMostEncompassingType (IList<TypeSpec> types)
 		{
-			TypeSpec best = null;
-
 			if (types.Count == 0)
 				return null;
 
 			if (types.Count == 1)
 				return types [0];
 
-			foreach (TypeSpec t in types) {
-				if (best == null) {
-					best = t;
-					continue;
-				}
+			TypeSpec best = null;
+			for (int i = 0; i < types.Count; ++i) {
+				int ii = 0;
+				for (; ii < types.Count; ++ii) {
+					if (ii == i)
+						continue;
 
-				var expr = new EmptyExpression (best);
-				if (ImplicitStandardConversionExists (expr, t))
-					best = t;
-			}
+					var expr = new EmptyExpression (types[ii]);
+					if (!ImplicitStandardConversionExists (expr, types [i])) {
+						ii = 0;
+						break;
+					}
+				}
 
-			foreach (TypeSpec t in types) {
-				if (best == t)
+				if (ii == 0)
 					continue;
 
-				var expr = new EmptyExpression (best);
-				if (!ImplicitStandardConversionExists (expr, best)) {
-					best = null;
-					break;
+				if (best == null) {
+					best = types[i];
+					continue;
 				}
+
+				// Indicates multiple best types
+				return InternalType.FakeInternalType;
 			}
 
 			return best;
@@ -1037,7 +1062,7 @@ namespace Mono.CSharp {
 
 			if (source_type.IsNullableType) {
 				// No implicit conversion S? -> T for non-reference types
-				if (implicitOnly && !TypeManager.IsReferenceType (target_type) && !target_type.IsNullableType)
+				if (implicitOnly && !TypeSpec.IsReferenceType (target_type) && !target_type.IsNullableType)
 					return null;
 
 				source_type_expr = Nullable.Unwrap.Create (source);
@@ -1130,6 +1155,8 @@ namespace Mono.CSharp {
 						"Ambiguous user defined operators `{0}' and `{1}' when converting from `{2}' to `{3}'",
 						ambig_arg.GetSignatureForError (), most_specific_operator.GetSignatureForError (),
 						source.Type.GetSignatureForError (), target.GetSignatureForError ());
+
+					return ErrorExpression.Instance;
 				}
 			}
 
@@ -1173,7 +1200,7 @@ namespace Mono.CSharp {
 			// Source expression is of nullable type, lift the result in the case it's null and
 			// not nullable/lifted user operator is used
 			//
-			if (source_type_expr is Nullable.Unwrap && !s_x.IsNullableType && (TypeManager.IsReferenceType (target) || target_type != target))
+			if (source_type_expr is Nullable.Unwrap && !s_x.IsNullableType && (TypeSpec.IsReferenceType (target) || target_type != target))
 				source = new Nullable.Lifted (source, source_type_expr, target).Resolve (ec);
 			else if (target_type != target)
 				source = Nullable.Wrap.Create (source, target);
@@ -1296,6 +1323,10 @@ namespace Mono.CSharp {
 			if (e != null)
 				return e;
 
+			e = ImplicitBoxingConversion (expr, expr_type, target_type);
+			if (e != null)
+				return e;
+
 			if (expr is IntegralConstant && TypeManager.IsEnumType (target_type)){
 				var i = (IntegralConstant) expr;
 				//
@@ -1342,12 +1373,11 @@ namespace Mono.CSharp {
 			if (expr_type == InternalType.Arglist && target_type == ec.Module.PredefinedTypes.ArgIterator.TypeSpec)
 				return expr;
 
-			if (TypeSpecComparer.IsEqual (expr_type, target_type)) {
-				if (expr_type == target_type)
-					return expr;
-
-				return EmptyCast.Create (expr, target_type);
-			}
+			//
+			// dynamic erasure conversion on value types
+			//
+			if (expr_type.IsStruct && TypeSpecComparer.IsEqual (expr_type, target_type))
+				return expr_type == target_type ? expr : EmptyCast.Create (expr, target_type);
 
 			return null;
 		}
@@ -1799,11 +1829,11 @@ namespace Mono.CSharp {
 					if (source_array.Rank == target_array.Rank) {
 
 						source_type = source_array.Element;
-						if (!TypeManager.IsReferenceType (source_type))
+						if (!TypeSpec.IsReferenceType (source_type))
 							return null;
 
 						var target_element = target_array.Element;
-						if (!TypeManager.IsReferenceType (target_element))
+						if (!TypeSpec.IsReferenceType (target_element))
 							return null;
 
 						if (ExplicitReferenceConversionExists (source_type, target_element))
@@ -1866,7 +1896,7 @@ namespace Mono.CSharp {
 						//
 						//If TP is contravariant, both are either identical or reference types
 						//
-						if (TypeManager.IsReferenceType (targs_src[i]) && TypeManager.IsReferenceType (targs_dst[i]))
+						if (TypeSpec.IsReferenceType (targs_src[i]) && TypeSpec.IsReferenceType (targs_dst[i]))
 							continue;
 					}
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.cs
index e0dc4b101..0d28d9d2b 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.cs
@@ -738,7 +738,9 @@ namespace Mono.CSharp
 //t    "unary_expression : BANG prefixed_unary_expression",
 //t    "unary_expression : TILDE prefixed_unary_expression",
 //t    "unary_expression : cast_expression",
+//t    "unary_expression : await_expression",
 //t    "cast_expression : OPEN_PARENS_CAST type CLOSE_PARENS prefixed_unary_expression",
+//t    "await_expression : AWAIT unary_expression",
 //t    "prefixed_unary_expression : unary_expression",
 //t    "prefixed_unary_expression : PLUS prefixed_unary_expression",
 //t    "prefixed_unary_expression : MINUS prefixed_unary_expression",
@@ -1172,8 +1174,8 @@ namespace Mono.CSharp
     "VOLATILE","WHERE","WHILE","ARGLIST","PARTIAL","ARROW","FROM",
     "FROM_FIRST","JOIN","ON","EQUALS","SELECT","GROUP","BY","LET",
     "ORDERBY","ASCENDING","DESCENDING","INTO","INTERR_NULLABLE",
-    "EXTERN_ALIAS","ASYNC","REFVALUE","REFTYPE","MAKEREF","GET","SET",
-    "LAST_KEYWORD","OPEN_BRACE","CLOSE_BRACE","OPEN_BRACKET",
+    "EXTERN_ALIAS","REFVALUE","REFTYPE","MAKEREF","ASYNC","AWAIT","GET",
+    "SET","LAST_KEYWORD","OPEN_BRACE","CLOSE_BRACE","OPEN_BRACKET",
     "CLOSE_BRACKET","OPEN_PARENS","CLOSE_PARENS","DOT","COMMA","COLON",
     "SEMICOLON","TILDE","PLUS","MINUS","BANG","ASSIGN","OP_LT","OP_GT",
     "BITWISE_AND","BITWISE_OR","STAR","PERCENT","DIV","CARRET","INTERR",
@@ -1373,20 +1375,20 @@ namespace Mono.CSharp
         yyVal = yyV > yyTop ? null : yyVals[yyV]; // yyVal = yyDefault(yyV > yyTop ? null : yyVals[yyV]);
         switch (yyN) {
 case 1:
-#line 379 "cs-parser.jay"
+#line 380 "cs-parser.jay"
   {
 		Lexer.check_incorrect_doc_comment ();
 	  }
   break;
 case 2:
-#line 380 "cs-parser.jay"
+#line 381 "cs-parser.jay"
   { Lexer.CompleteOnEOF = false; }
   break;
 case 6:
   case_6();
   break;
 case 7:
-#line 397 "cs-parser.jay"
+#line 398 "cs-parser.jay"
   {
 		module.AddAttributes ((Attributes) yyVals[0+yyTop], current_namespace);
 	  }
@@ -1398,7 +1400,7 @@ case 13:
   case_13();
   break;
 case 14:
-#line 435 "cs-parser.jay"
+#line 436 "cs-parser.jay"
   {
 	  	syntax_error (GetLocation (yyVals[-1+yyTop]), "`alias' expected");   /* TODO: better*/
 	  }
@@ -1443,7 +1445,7 @@ case 41:
   case_41();
   break;
 case 42:
-#line 628 "cs-parser.jay"
+#line 625 "cs-parser.jay"
   {
 		current_namespace.DeclarationFound = true;
 	  }
@@ -1473,18 +1475,18 @@ case 57:
   case_57();
   break;
 case 58:
-#line 721 "cs-parser.jay"
+#line 717 "cs-parser.jay"
   { yyVal = "event"; }
   break;
 case 59:
-#line 722 "cs-parser.jay"
+#line 718 "cs-parser.jay"
   { yyVal = "return"; }
   break;
 case 60:
   case_60();
   break;
 case 61:
-#line 739 "cs-parser.jay"
+#line 735 "cs-parser.jay"
   {
 		yyVal = new List<Attribute> (4) { (Attribute) yyVals[0+yyTop] };
 	  }
@@ -1493,7 +1495,7 @@ case 62:
   case_62();
   break;
 case 63:
-#line 753 "cs-parser.jay"
+#line 749 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -1502,17 +1504,17 @@ case 64:
   case_64();
   break;
 case 66:
-#line 774 "cs-parser.jay"
+#line 770 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 67:
-#line 778 "cs-parser.jay"
+#line 774 "cs-parser.jay"
   {
 		yyVal = yyVals[-1+yyTop];
 	  }
   break;
 case 68:
-#line 783 "cs-parser.jay"
+#line 779 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 69:
@@ -1528,13 +1530,13 @@ case 72:
   case_72();
   break;
 case 73:
-#line 827 "cs-parser.jay"
+#line 823 "cs-parser.jay"
   {
 	  	yyVal = new Argument ((Expression) yyVals[0+yyTop]);
 	  }
   break;
 case 75:
-#line 835 "cs-parser.jay"
+#line 831 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -1546,17 +1548,17 @@ case 77:
   case_77();
   break;
 case 78:
-#line 860 "cs-parser.jay"
+#line 856 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 79:
-#line 864 "cs-parser.jay"
+#line 860 "cs-parser.jay"
   { 
 		yyVal = Argument.AType.Ref;
 	  }
   break;
 case 80:
-#line 868 "cs-parser.jay"
+#line 864 "cs-parser.jay"
   { 
 		yyVal = Argument.AType.Out;
 	  }
@@ -1565,7 +1567,7 @@ case 95:
   case_95();
   break;
 case 96:
-#line 909 "cs-parser.jay"
+#line 905 "cs-parser.jay"
   {
 		lexer.ConstraintsParsing = true;
 	  }
@@ -1583,7 +1585,7 @@ case 100:
   case_100();
   break;
 case 101:
-#line 941 "cs-parser.jay"
+#line 937 "cs-parser.jay"
   {
 		Error_SyntaxError (yyToken);
 	  }
@@ -1592,7 +1594,7 @@ case 102:
   case_102();
   break;
 case 103:
-#line 953 "cs-parser.jay"
+#line 949 "cs-parser.jay"
   {
 		lbag.AppendToMember (current_class, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
@@ -1604,13 +1606,13 @@ case 119:
   case_119();
   break;
 case 122:
-#line 1022 "cs-parser.jay"
+#line 1018 "cs-parser.jay"
   {
 		current_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
   break;
 case 123:
-#line 1026 "cs-parser.jay"
+#line 1022 "cs-parser.jay"
   {
 		current_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
@@ -1619,7 +1621,7 @@ case 124:
   case_124();
   break;
 case 125:
-#line 1042 "cs-parser.jay"
+#line 1038 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -1643,7 +1645,7 @@ case 133:
   case_133();
   break;
 case 134:
-#line 1121 "cs-parser.jay"
+#line 1117 "cs-parser.jay"
   {
 		report.Error (1641, GetLocation (yyVals[-1+yyTop]), "A fixed size buffer field must have the array size specifier after the field name");
 	  }
@@ -1655,13 +1657,13 @@ case 137:
   case_137();
   break;
 case 140:
-#line 1151 "cs-parser.jay"
+#line 1147 "cs-parser.jay"
   {
 		current_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
   break;
 case 141:
-#line 1155 "cs-parser.jay"
+#line 1151 "cs-parser.jay"
   {
 		current_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
@@ -1670,7 +1672,7 @@ case 142:
   case_142();
   break;
 case 143:
-#line 1168 "cs-parser.jay"
+#line 1164 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -1679,13 +1681,13 @@ case 144:
   case_144();
   break;
 case 147:
-#line 1187 "cs-parser.jay"
+#line 1183 "cs-parser.jay"
   {
 		current_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
   break;
 case 148:
-#line 1191 "cs-parser.jay"
+#line 1187 "cs-parser.jay"
   {
 		current_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
@@ -1694,7 +1696,7 @@ case 149:
   case_149();
   break;
 case 150:
-#line 1207 "cs-parser.jay"
+#line 1203 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -1715,13 +1717,13 @@ case 157:
   case_157();
   break;
 case 158:
-#line 1264 "cs-parser.jay"
+#line 1260 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.All;
 	  }
   break;
 case 159:
-#line 1268 "cs-parser.jay"
+#line 1264 "cs-parser.jay"
   {
 		lexer.ConstraintsParsing = true;
 	  }
@@ -1730,13 +1732,13 @@ case 160:
   case_160();
   break;
 case 161:
-#line 1309 "cs-parser.jay"
+#line 1305 "cs-parser.jay"
   {
 	  	valid_param_mod = ParameterModifierType.All;
 	  }
   break;
 case 162:
-#line 1313 "cs-parser.jay"
+#line 1309 "cs-parser.jay"
   {
 		lexer.ConstraintsParsing = true;
 	  }
@@ -1748,11 +1750,11 @@ case 164:
   case_164();
   break;
 case 166:
-#line 1389 "cs-parser.jay"
+#line 1385 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 167:
-#line 1393 "cs-parser.jay"
+#line 1389 "cs-parser.jay"
   { yyVal = ParametersCompiled.EmptyReadOnlyParameters; }
   break;
 case 169:
@@ -1777,13 +1779,13 @@ case 175:
   case_175();
   break;
 case 176:
-#line 1452 "cs-parser.jay"
+#line 1448 "cs-parser.jay"
   {
 		yyVal = new ParametersCompiled (new Parameter[] { (Parameter) yyVals[0+yyTop] } );
 	  }
   break;
 case 177:
-#line 1456 "cs-parser.jay"
+#line 1452 "cs-parser.jay"
   {
 		yyVal = new ParametersCompiled (new Parameter [] { new ArglistParameter (GetLocation (yyVals[0+yyTop])) }, true);
 	  }
@@ -1807,7 +1809,7 @@ case 183:
   case_183();
   break;
 case 184:
-#line 1531 "cs-parser.jay"
+#line 1527 "cs-parser.jay"
   {
 	  	++lexer.parsing_block;
 	  }
@@ -1816,7 +1818,7 @@ case 185:
   case_185();
   break;
 case 186:
-#line 1572 "cs-parser.jay"
+#line 1568 "cs-parser.jay"
   { yyVal = Parameter.Modifier.NONE; }
   break;
 case 188:
@@ -1850,7 +1852,7 @@ case 197:
   case_197();
   break;
 case 198:
-#line 1670 "cs-parser.jay"
+#line 1666 "cs-parser.jay"
   {
 		Error_DuplicateParameterModifier (GetLocation (yyVals[-1+yyTop]), Parameter.Modifier.PARAMS);
 	  }
@@ -1871,7 +1873,7 @@ case 203:
   case_203();
   break;
 case 204:
-#line 1724 "cs-parser.jay"
+#line 1720 "cs-parser.jay"
   {
 	  	valid_param_mod = ParameterModifierType.Params | ParameterModifierType.DefaultValue;
 	  }
@@ -1880,7 +1882,7 @@ case 205:
   case_205();
   break;
 case 206:
-#line 1754 "cs-parser.jay"
+#line 1750 "cs-parser.jay"
   {
 		  lexer.PropertyParsing = false;
 	  }
@@ -1910,7 +1912,7 @@ case 219:
   case_219();
   break;
 case 220:
-#line 1896 "cs-parser.jay"
+#line 1892 "cs-parser.jay"
   {
 		lexer.ConstraintsParsing = true;
 	  }
@@ -1928,43 +1930,43 @@ case 224:
   case_224();
   break;
 case 225:
-#line 1929 "cs-parser.jay"
+#line 1925 "cs-parser.jay"
   {
 		Error_SyntaxError (yyToken);	  
 	  }
   break;
 case 230:
-#line 1946 "cs-parser.jay"
+#line 1942 "cs-parser.jay"
   {
 		report.Error (525, GetLocation (yyVals[0+yyTop]), "Interfaces cannot contain fields or constants");
 	  }
   break;
 case 231:
-#line 1950 "cs-parser.jay"
+#line 1946 "cs-parser.jay"
   {
 		report.Error (525, GetLocation (yyVals[0+yyTop]), "Interfaces cannot contain fields or constants");
 	  }
   break;
 case 236:
-#line 1958 "cs-parser.jay"
+#line 1954 "cs-parser.jay"
   {
 	  	report.Error (567, GetLocation (yyVals[0+yyTop]), "Interfaces cannot contain operators");
 	  }
   break;
 case 237:
-#line 1962 "cs-parser.jay"
+#line 1958 "cs-parser.jay"
   {
 	  	report.Error (526, GetLocation (yyVals[0+yyTop]), "Interfaces cannot contain contructors");
 	  }
   break;
 case 238:
-#line 1966 "cs-parser.jay"
+#line 1962 "cs-parser.jay"
   {
 	  	report.Error (524, GetLocation (yyVals[0+yyTop]), "Interfaces cannot declare classes, structs, interfaces, delegates, or enumerations");
 	  }
   break;
 case 239:
-#line 1972 "cs-parser.jay"
+#line 1968 "cs-parser.jay"
   {
 	  }
   break;
@@ -1972,14 +1974,14 @@ case 240:
   case_240();
   break;
 case 242:
-#line 1999 "cs-parser.jay"
+#line 1995 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 244:
   case_244();
   break;
 case 245:
-#line 2015 "cs-parser.jay"
+#line 2011 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.DefaultValue;
 	  }
@@ -1988,95 +1990,95 @@ case 246:
   case_246();
   break;
 case 248:
-#line 2061 "cs-parser.jay"
+#line 2057 "cs-parser.jay"
   { yyVal = Operator.OpType.LogicalNot; }
   break;
 case 249:
-#line 2062 "cs-parser.jay"
+#line 2058 "cs-parser.jay"
   { yyVal = Operator.OpType.OnesComplement; }
   break;
 case 250:
-#line 2063 "cs-parser.jay"
+#line 2059 "cs-parser.jay"
   { yyVal = Operator.OpType.Increment; }
   break;
 case 251:
-#line 2064 "cs-parser.jay"
+#line 2060 "cs-parser.jay"
   { yyVal = Operator.OpType.Decrement; }
   break;
 case 252:
-#line 2065 "cs-parser.jay"
+#line 2061 "cs-parser.jay"
   { yyVal = Operator.OpType.True; }
   break;
 case 253:
-#line 2066 "cs-parser.jay"
+#line 2062 "cs-parser.jay"
   { yyVal = Operator.OpType.False; }
   break;
 case 254:
-#line 2068 "cs-parser.jay"
+#line 2064 "cs-parser.jay"
   { yyVal = Operator.OpType.Addition; }
   break;
 case 255:
-#line 2069 "cs-parser.jay"
+#line 2065 "cs-parser.jay"
   { yyVal = Operator.OpType.Subtraction; }
   break;
 case 256:
-#line 2071 "cs-parser.jay"
+#line 2067 "cs-parser.jay"
   { yyVal = Operator.OpType.Multiply; }
   break;
 case 257:
-#line 2072 "cs-parser.jay"
+#line 2068 "cs-parser.jay"
   {  yyVal = Operator.OpType.Division; }
   break;
 case 258:
-#line 2073 "cs-parser.jay"
+#line 2069 "cs-parser.jay"
   { yyVal = Operator.OpType.Modulus; }
   break;
 case 259:
-#line 2074 "cs-parser.jay"
+#line 2070 "cs-parser.jay"
   { yyVal = Operator.OpType.BitwiseAnd; }
   break;
 case 260:
-#line 2075 "cs-parser.jay"
+#line 2071 "cs-parser.jay"
   { yyVal = Operator.OpType.BitwiseOr; }
   break;
 case 261:
-#line 2076 "cs-parser.jay"
+#line 2072 "cs-parser.jay"
   { yyVal = Operator.OpType.ExclusiveOr; }
   break;
 case 262:
-#line 2077 "cs-parser.jay"
+#line 2073 "cs-parser.jay"
   { yyVal = Operator.OpType.LeftShift; }
   break;
 case 263:
-#line 2078 "cs-parser.jay"
+#line 2074 "cs-parser.jay"
   { yyVal = Operator.OpType.RightShift; }
   break;
 case 264:
-#line 2079 "cs-parser.jay"
+#line 2075 "cs-parser.jay"
   { yyVal = Operator.OpType.Equality; }
   break;
 case 265:
-#line 2080 "cs-parser.jay"
+#line 2076 "cs-parser.jay"
   { yyVal = Operator.OpType.Inequality; }
   break;
 case 266:
-#line 2081 "cs-parser.jay"
+#line 2077 "cs-parser.jay"
   { yyVal = Operator.OpType.GreaterThan; }
   break;
 case 267:
-#line 2082 "cs-parser.jay"
+#line 2078 "cs-parser.jay"
   { yyVal = Operator.OpType.LessThan; }
   break;
 case 268:
-#line 2083 "cs-parser.jay"
+#line 2079 "cs-parser.jay"
   { yyVal = Operator.OpType.GreaterThanOrEqual; }
   break;
 case 269:
-#line 2084 "cs-parser.jay"
+#line 2080 "cs-parser.jay"
   { yyVal = Operator.OpType.LessThanOrEqual; }
   break;
 case 270:
-#line 2091 "cs-parser.jay"
+#line 2087 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.DefaultValue;
 	  }
@@ -2085,7 +2087,7 @@ case 271:
   case_271();
   break;
 case 272:
-#line 2110 "cs-parser.jay"
+#line 2106 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.DefaultValue;
 	  }
@@ -2112,11 +2114,11 @@ case 279:
   case_279();
   break;
 case 281:
-#line 2213 "cs-parser.jay"
+#line 2209 "cs-parser.jay"
   { current_block = null; yyVal = null; }
   break;
 case 284:
-#line 2225 "cs-parser.jay"
+#line 2221 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -2125,7 +2127,7 @@ case 285:
   case_285();
   break;
 case 286:
-#line 2235 "cs-parser.jay"
+#line 2231 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -2158,7 +2160,7 @@ case 295:
   case_295();
   break;
 case 297:
-#line 2344 "cs-parser.jay"
+#line 2340 "cs-parser.jay"
   {
 	  	++lexer.parsing_block;
 	  }
@@ -2167,13 +2169,13 @@ case 298:
   case_298();
   break;
 case 301:
-#line 2361 "cs-parser.jay"
+#line 2357 "cs-parser.jay"
   {
 		current_event_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
   break;
 case 302:
-#line 2365 "cs-parser.jay"
+#line 2361 "cs-parser.jay"
   {
 		current_event_field.AddDeclarator ((FieldDeclarator) yyVals[0+yyTop]);
 	  }
@@ -2182,7 +2184,7 @@ case 303:
   case_303();
   break;
 case 304:
-#line 2378 "cs-parser.jay"
+#line 2374 "cs-parser.jay"
   {
 		++lexer.parsing_block;
 	  }
@@ -2194,7 +2196,7 @@ case 306:
   case_306();
   break;
 case 307:
-#line 2403 "cs-parser.jay"
+#line 2399 "cs-parser.jay"
   {
 		yyVal = yyVals[0+yyTop];
 	  }
@@ -2242,7 +2244,7 @@ case 325:
   case_325();
   break;
 case 328:
-#line 2558 "cs-parser.jay"
+#line 2554 "cs-parser.jay"
   {
 	  	lbag.AddLocation (yyVals[-1+yyTop], GetLocation (yyVals[0+yyTop]));
 	  }
@@ -2260,7 +2262,7 @@ case 333:
   case_333();
   break;
 case 334:
-#line 2616 "cs-parser.jay"
+#line 2612 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out | ParameterModifierType.Params | ParameterModifierType.DefaultValue;
 	  }
@@ -2269,7 +2271,7 @@ case 335:
   case_335();
   break;
 case 336:
-#line 2636 "cs-parser.jay"
+#line 2632 "cs-parser.jay"
   {
 		lexer.ConstraintsParsing = false;
 	  }
@@ -2302,7 +2304,7 @@ case 349:
   case_349();
   break;
 case 350:
-#line 2734 "cs-parser.jay"
+#line 2730 "cs-parser.jay"
   {
 		lexer.parsing_generic_declaration = true;
 	  }
@@ -2347,13 +2349,13 @@ case 365:
   case_365();
   break;
 case 367:
-#line 2852 "cs-parser.jay"
+#line 2848 "cs-parser.jay"
   {
 		yyVal = new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[0+yyTop]));
 	  }
   break;
 case 368:
-#line 2859 "cs-parser.jay"
+#line 2855 "cs-parser.jay"
   {
 		lexer.parsing_generic_declaration = true;
 	  }
@@ -2368,7 +2370,7 @@ case 374:
   case_374();
   break;
 case 376:
-#line 2897 "cs-parser.jay"
+#line 2893 "cs-parser.jay"
   {
 		yyVal = new ComposedCast ((FullNamedExpression) yyVals[-1+yyTop], (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
@@ -2377,7 +2379,7 @@ case 377:
   case_377();
   break;
 case 378:
-#line 2917 "cs-parser.jay"
+#line 2913 "cs-parser.jay"
   {
 		yyVal = new ComposedCast (((MemberName) yyVals[-1+yyTop]).GetTypeExpression (), (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
@@ -2386,13 +2388,13 @@ case 379:
   case_379();
   break;
 case 380:
-#line 2926 "cs-parser.jay"
+#line 2922 "cs-parser.jay"
   {
 		yyVal = new ComposedCast ((FullNamedExpression) yyVals[-1+yyTop], (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
   break;
 case 381:
-#line 2930 "cs-parser.jay"
+#line 2926 "cs-parser.jay"
   {
 		yyVal = new ComposedCast (new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[-1+yyTop])), (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
@@ -2410,63 +2412,63 @@ case 385:
   case_385();
   break;
 case 386:
-#line 2968 "cs-parser.jay"
+#line 2964 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Object, GetLocation (yyVals[0+yyTop])); }
   break;
 case 387:
-#line 2969 "cs-parser.jay"
+#line 2965 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.String, GetLocation (yyVals[0+yyTop])); }
   break;
 case 388:
-#line 2970 "cs-parser.jay"
+#line 2966 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Bool, GetLocation (yyVals[0+yyTop])); }
   break;
 case 389:
-#line 2971 "cs-parser.jay"
+#line 2967 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Decimal, GetLocation (yyVals[0+yyTop])); }
   break;
 case 390:
-#line 2972 "cs-parser.jay"
+#line 2968 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Float, GetLocation (yyVals[0+yyTop])); }
   break;
 case 391:
-#line 2973 "cs-parser.jay"
+#line 2969 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Double, GetLocation (yyVals[0+yyTop])); }
   break;
 case 393:
-#line 2978 "cs-parser.jay"
+#line 2974 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.SByte, GetLocation (yyVals[0+yyTop])); }
   break;
 case 394:
-#line 2979 "cs-parser.jay"
+#line 2975 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Byte, GetLocation (yyVals[0+yyTop])); }
   break;
 case 395:
-#line 2980 "cs-parser.jay"
+#line 2976 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Short, GetLocation (yyVals[0+yyTop])); }
   break;
 case 396:
-#line 2981 "cs-parser.jay"
+#line 2977 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.UShort, GetLocation (yyVals[0+yyTop])); }
   break;
 case 397:
-#line 2982 "cs-parser.jay"
+#line 2978 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Int, GetLocation (yyVals[0+yyTop])); }
   break;
 case 398:
-#line 2983 "cs-parser.jay"
+#line 2979 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.UInt, GetLocation (yyVals[0+yyTop])); }
   break;
 case 399:
-#line 2984 "cs-parser.jay"
+#line 2980 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Long, GetLocation (yyVals[0+yyTop])); }
   break;
 case 400:
-#line 2985 "cs-parser.jay"
+#line 2981 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.ULong, GetLocation (yyVals[0+yyTop])); }
   break;
 case 401:
-#line 2986 "cs-parser.jay"
+#line 2982 "cs-parser.jay"
   { yyVal = new TypeExpression (compiler.BuiltinTypes.Char, GetLocation (yyVals[0+yyTop])); }
   break;
 case 422:
@@ -2476,22 +2478,22 @@ case 423:
   case_423();
   break;
 case 427:
-#line 3033 "cs-parser.jay"
+#line 3029 "cs-parser.jay"
   { yyVal = new NullLiteral (GetLocation (yyVals[0+yyTop])); }
   break;
 case 428:
-#line 3037 "cs-parser.jay"
+#line 3033 "cs-parser.jay"
   { yyVal = new BoolLiteral (compiler.BuiltinTypes, true, GetLocation (yyVals[0+yyTop])); }
   break;
 case 429:
-#line 3038 "cs-parser.jay"
+#line 3034 "cs-parser.jay"
   { yyVal = new BoolLiteral (compiler.BuiltinTypes, false, GetLocation (yyVals[0+yyTop])); }
   break;
 case 434:
   case_434();
   break;
 case 435:
-#line 3071 "cs-parser.jay"
+#line 3067 "cs-parser.jay"
   {
 		yyVal = new ParenthesizedExpression ((Expression) yyVals[-1+yyTop]);
 	  }
@@ -2509,7 +2511,7 @@ case 439:
   case_439();
   break;
 case 440:
-#line 3102 "cs-parser.jay"
+#line 3099 "cs-parser.jay"
   {
 		yyVal = new CompletionMemberAccess ((Expression) yyVals[-2+yyTop], null,GetLocation (yyVals[0+yyTop]));
 	  }
@@ -2518,7 +2520,7 @@ case 441:
   case_441();
   break;
 case 442:
-#line 3110 "cs-parser.jay"
+#line 3107 "cs-parser.jay"
   {
 		yyVal = new CompletionMemberAccess ((Expression) yyVals[-2+yyTop], null, lexer.Location);
 	  }
@@ -2530,7 +2532,7 @@ case 444:
   case_444();
   break;
 case 445:
-#line 3126 "cs-parser.jay"
+#line 3123 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 447:
@@ -2540,11 +2542,11 @@ case 448:
   case_448();
   break;
 case 449:
-#line 3149 "cs-parser.jay"
+#line 3146 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 450:
-#line 3153 "cs-parser.jay"
+#line 3150 "cs-parser.jay"
   {
 		yyVal = yyVals[0+yyTop];
 	}
@@ -2562,7 +2564,7 @@ case 454:
   case_454();
   break;
 case 455:
-#line 3185 "cs-parser.jay"
+#line 3182 "cs-parser.jay"
   {
 		yyVal = new CompletionElementInitializer (null, GetLocation (yyVals[0+yyTop]));
 	  }
@@ -2577,7 +2579,7 @@ case 458:
   case_458();
   break;
 case 461:
-#line 3213 "cs-parser.jay"
+#line 3210 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 463:
@@ -2596,7 +2598,7 @@ case 467:
   case_467();
   break;
 case 468:
-#line 3265 "cs-parser.jay"
+#line 3262 "cs-parser.jay"
   {
 		yyVal = new Argument ((Expression) yyVals[0+yyTop]);
 	  }
@@ -2632,13 +2634,13 @@ case 482:
   case_482();
   break;
 case 483:
-#line 3352 "cs-parser.jay"
+#line 3349 "cs-parser.jay"
   {
 	  	yyVal = new Argument ((Expression) yyVals[0+yyTop]);
 	  }
   break;
 case 485:
-#line 3360 "cs-parser.jay"
+#line 3357 "cs-parser.jay"
   {
 		yyVal = new This (GetLocation (yyVals[0+yyTop]));
 	  }
@@ -2650,13 +2652,13 @@ case 487:
   case_487();
   break;
 case 488:
-#line 3380 "cs-parser.jay"
+#line 3377 "cs-parser.jay"
   {
 		yyVal = new UnaryMutator (UnaryMutator.Mode.PostIncrement, (Expression) yyVals[-1+yyTop], GetLocation (yyVals[0+yyTop]));
 	  }
   break;
 case 489:
-#line 3387 "cs-parser.jay"
+#line 3384 "cs-parser.jay"
   {
 		yyVal = new UnaryMutator (UnaryMutator.Mode.PostDecrement, (Expression) yyVals[-1+yyTop], GetLocation (yyVals[0+yyTop]));
 	  }
@@ -2683,7 +2685,7 @@ case 496:
   case_496();
   break;
 case 497:
-#line 3453 "cs-parser.jay"
+#line 3450 "cs-parser.jay"
   {
 		++lexer.parsing_type;
 	  }
@@ -2695,7 +2697,7 @@ case 499:
   case_499();
   break;
 case 502:
-#line 3480 "cs-parser.jay"
+#line 3477 "cs-parser.jay"
   { yyVal = null; }
   break;
 case 504:
@@ -2726,25 +2728,25 @@ case 515:
   case_515();
   break;
 case 516:
-#line 3556 "cs-parser.jay"
+#line 3553 "cs-parser.jay"
   {
 		yyVal = 2;
 	  }
   break;
 case 517:
-#line 3560 "cs-parser.jay"
+#line 3557 "cs-parser.jay"
   {
 		yyVal = ((int) yyVals[-1+yyTop]) + 1;
 	  }
   break;
 case 518:
-#line 3567 "cs-parser.jay"
+#line 3564 "cs-parser.jay"
   {
 		yyVal = null;
 	  }
   break;
 case 519:
-#line 3571 "cs-parser.jay"
+#line 3568 "cs-parser.jay"
   {
 		yyVal = yyVals[0+yyTop];
 	  }
@@ -2762,7 +2764,7 @@ case 523:
   case_523();
   break;
 case 524:
-#line 3615 "cs-parser.jay"
+#line 3612 "cs-parser.jay"
   {
 	  	lexer.TypeOfParsing = true;
 	  }
@@ -2807,7 +2809,7 @@ case 539:
   case_539();
   break;
 case 540:
-#line 3728 "cs-parser.jay"
+#line 3726 "cs-parser.jay"
   {
 		start_anonymous (false, (ParametersCompiled) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
@@ -2816,13 +2818,13 @@ case 541:
   case_541();
   break;
 case 542:
-#line 3744 "cs-parser.jay"
+#line 3742 "cs-parser.jay"
   {
 		yyVal = ParametersCompiled.Undefined;
 	  }
   break;
 case 544:
-#line 3752 "cs-parser.jay"
+#line 3750 "cs-parser.jay"
   {
 	  	valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out;
 	  }
@@ -2834,112 +2836,115 @@ case 546:
   case_546();
   break;
 case 548:
-#line 3778 "cs-parser.jay"
+#line 3776 "cs-parser.jay"
   {
 		yyVal = new Unary (Unary.Operator.LogicalNot, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
 case 549:
-#line 3782 "cs-parser.jay"
+#line 3780 "cs-parser.jay"
   {
 		yyVal = new Unary (Unary.Operator.OnesComplement, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 551:
-  case_551();
+case 552:
+  case_552();
   break;
 case 553:
-#line 3803 "cs-parser.jay"
+#line 3797 "cs-parser.jay"
+  {
+		yyVal = new Await ((Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+	 }
+  break;
+case 555:
+#line 3809 "cs-parser.jay"
   { 
 	  	yyVal = new Unary (Unary.Operator.UnaryPlus, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 554:
-#line 3807 "cs-parser.jay"
+case 556:
+#line 3813 "cs-parser.jay"
   { 
 		yyVal = new Unary (Unary.Operator.UnaryNegation, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 555:
-#line 3811 "cs-parser.jay"
+case 557:
+#line 3817 "cs-parser.jay"
   {
 		yyVal = new UnaryMutator (UnaryMutator.Mode.PreIncrement, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 556:
-#line 3815 "cs-parser.jay"
+case 558:
+#line 3821 "cs-parser.jay"
   {
 		yyVal = new UnaryMutator (UnaryMutator.Mode.PreDecrement, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 557:
-#line 3819 "cs-parser.jay"
+case 559:
+#line 3825 "cs-parser.jay"
   {
 		yyVal = new Indirection ((Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 558:
-#line 3823 "cs-parser.jay"
+case 560:
+#line 3829 "cs-parser.jay"
   {
 		yyVal = new Unary (Unary.Operator.AddressOf, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
-case 560:
-  case_560();
-  break;
-case 561:
-  case_561();
-  break;
 case 562:
   case_562();
   break;
+case 563:
+  case_563();
+  break;
 case 564:
   case_564();
   break;
-case 565:
-#line 3855 "cs-parser.jay"
-  {
-		yyVal = new Binary (Binary.Operator.Subtraction, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
-	  }
-  break;
 case 566:
   case_566();
   break;
 case 567:
-#line 3864 "cs-parser.jay"
+#line 3861 "cs-parser.jay"
   {
-		yyVal = new As ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+		yyVal = new Binary (Binary.Operator.Subtraction, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
 case 568:
-#line 3868 "cs-parser.jay"
+  case_568();
+  break;
+case 569:
+#line 3870 "cs-parser.jay"
   {
-		yyVal = new Is ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+		yyVal = new As ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
 case 570:
-  case_570();
+#line 3874 "cs-parser.jay"
+  {
+		yyVal = new Is ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+	  }
   break;
-case 571:
-  case_571();
+case 572:
+  case_572();
   break;
 case 573:
   case_573();
   break;
-case 574:
-  case_574();
-  break;
 case 575:
   case_575();
   break;
 case 576:
   case_576();
   break;
+case 577:
+  case_577();
+  break;
 case 578:
   case_578();
   break;
-case 579:
-  case_579();
+case 580:
+  case_580();
   break;
 case 581:
   case_581();
@@ -2962,17 +2967,14 @@ case 591:
 case 593:
   case_593();
   break;
-case 594:
-#line 3992 "cs-parser.jay"
-  {
-		yyVal = new SimpleAssign ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
-	  }
-  break;
 case 595:
   case_595();
   break;
 case 596:
-  case_596();
+#line 3998 "cs-parser.jay"
+  {
+		yyVal = new SimpleAssign ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+	  }
   break;
 case 597:
   case_597();
@@ -3014,27 +3016,27 @@ case 609:
   case_609();
   break;
 case 610:
-#line 4087 "cs-parser.jay"
-  { yyVal = ParametersCompiled.EmptyReadOnlyParameters; }
+  case_610();
   break;
 case 611:
   case_611();
   break;
-case 614:
-#line 4102 "cs-parser.jay"
+case 612:
+#line 4093 "cs-parser.jay"
+  { yyVal = ParametersCompiled.EmptyReadOnlyParameters; }
+  break;
+case 613:
+  case_613();
+  break;
+case 616:
+#line 4108 "cs-parser.jay"
   {
 		start_block (lexer.Location);
 	  }
   break;
-case 615:
-  case_615();
-  break;
 case 617:
   case_617();
   break;
-case 618:
-  case_618();
-  break;
 case 619:
   case_619();
   break;
@@ -3047,39 +3049,39 @@ case 621:
 case 622:
   case_622();
   break;
-case 628:
-#line 4164 "cs-parser.jay"
-  {
-		yyVal = new ArglistAccess (GetLocation (yyVals[0+yyTop]));
-	  }
+case 623:
+  case_623();
   break;
-case 629:
-  case_629();
+case 624:
+  case_624();
   break;
 case 630:
-  case_630();
+#line 4170 "cs-parser.jay"
+  {
+		yyVal = new ArglistAccess (GetLocation (yyVals[0+yyTop]));
+	  }
   break;
 case 631:
   case_631();
   break;
+case 632:
+  case_632();
+  break;
 case 633:
-#line 4193 "cs-parser.jay"
+  case_633();
+  break;
+case 635:
+#line 4199 "cs-parser.jay"
   {
 		yyVal = new BooleanExpression ((Expression) yyVals[0+yyTop]);
 	  }
   break;
-case 634:
-#line 4206 "cs-parser.jay"
+case 636:
+#line 4212 "cs-parser.jay"
   {
 		lexer.ConstraintsParsing = true;
 	  }
   break;
-case 635:
-  case_635();
-  break;
-case 636:
-  case_636();
-  break;
 case 637:
   case_637();
   break;
@@ -3087,21 +3089,21 @@ case 638:
   case_638();
   break;
 case 639:
-#line 4245 "cs-parser.jay"
-  { yyVal = null; }
+  case_639();
   break;
 case 640:
-#line 4247 "cs-parser.jay"
-  { yyVal = yyVals[0+yyTop]; StoreModifierLocation (Modifiers.PARTIAL, GetLocation (yyVals[0+yyTop])); }
+  case_640();
   break;
 case 641:
-  case_641();
+#line 4251 "cs-parser.jay"
+  { yyVal = null; }
   break;
-case 644:
-  case_644();
+case 642:
+#line 4253 "cs-parser.jay"
+  { yyVal = yyVals[0+yyTop]; StoreModifierLocation (Modifiers.PARTIAL, GetLocation (yyVals[0+yyTop])); }
   break;
-case 645:
-  case_645();
+case 643:
+  case_643();
   break;
 case 646:
   case_646();
@@ -3145,24 +3147,24 @@ case 658:
 case 659:
   case_659();
   break;
+case 660:
+  case_660();
+  break;
 case 661:
-#line 4367 "cs-parser.jay"
+  case_661();
+  break;
+case 663:
+#line 4373 "cs-parser.jay"
   {
 		current_container.AddBasesForPart (current_class, (List<FullNamedExpression>) yyVals[0+yyTop]);
 	 }
   break;
-case 663:
-#line 4375 "cs-parser.jay"
+case 665:
+#line 4381 "cs-parser.jay"
   {
 		yyVal = yyVals[0+yyTop];
 	  }
   break;
-case 664:
-  case_664();
-  break;
-case 665:
-  case_665();
-  break;
 case 666:
   case_666();
   break;
@@ -3182,52 +3184,52 @@ case 671:
   case_671();
   break;
 case 672:
-#line 4464 "cs-parser.jay"
-  {
-		yyVal = new SpecialContraintExpr (SpecialConstraint.Class, GetLocation (yyVals[0+yyTop]));
-	  }
+  case_672();
   break;
 case 673:
-#line 4468 "cs-parser.jay"
-  {
-		yyVal = new SpecialContraintExpr (SpecialConstraint.Struct, GetLocation (yyVals[0+yyTop]));
-	  }
+  case_673();
   break;
 case 674:
-#line 4475 "cs-parser.jay"
+#line 4470 "cs-parser.jay"
   {
-		yyVal = Variance.None;
+		yyVal = new SpecialContraintExpr (SpecialConstraint.Class, GetLocation (yyVals[0+yyTop]));
 	  }
   break;
 case 675:
-  case_675();
+#line 4474 "cs-parser.jay"
+  {
+		yyVal = new SpecialContraintExpr (SpecialConstraint.Struct, GetLocation (yyVals[0+yyTop]));
+	  }
   break;
 case 676:
-#line 4489 "cs-parser.jay"
+#line 4481 "cs-parser.jay"
   {
-		yyVal = Variance.Covariant;
+		yyVal = Variance.None;
 	  }
   break;
 case 677:
-#line 4493 "cs-parser.jay"
-  {
-		yyVal = Variance.Contravariant;
-	  }
+  case_677();
   break;
 case 678:
-  case_678();
+#line 4495 "cs-parser.jay"
+  {
+		yyVal = Variance.Covariant;
+	  }
   break;
 case 679:
-#line 4518 "cs-parser.jay"
+#line 4499 "cs-parser.jay"
   {
-		yyVal = yyVals[0+yyTop];
+		yyVal = Variance.Contravariant;
 	  }
   break;
 case 680:
   case_680();
   break;
 case 681:
-  case_681();
+#line 4524 "cs-parser.jay"
+  {
+		yyVal = yyVals[0+yyTop];
+	  }
   break;
 case 682:
   case_682();
@@ -3235,39 +3237,39 @@ case 682:
 case 683:
   case_683();
   break;
-case 688:
-#line 4562 "cs-parser.jay"
+case 684:
+  case_684();
+  break;
+case 685:
+  case_685();
+  break;
+case 690:
+#line 4568 "cs-parser.jay"
   {
 		current_block.AddStatement ((Statement) yyVals[0+yyTop]);
 	  }
   break;
-case 689:
-#line 4566 "cs-parser.jay"
+case 691:
+#line 4572 "cs-parser.jay"
   {
 		current_block.AddStatement ((Statement) yyVals[0+yyTop]);
 	  }
   break;
-case 691:
-  case_691();
+case 693:
+  case_693();
   break;
-case 694:
-#line 4590 "cs-parser.jay"
+case 696:
+#line 4596 "cs-parser.jay"
   {
 		current_block.AddStatement ((Statement) yyVals[0+yyTop]);
 	  }
   break;
-case 695:
-#line 4594 "cs-parser.jay"
+case 697:
+#line 4600 "cs-parser.jay"
   {
 		current_block.AddStatement ((Statement) yyVals[0+yyTop]);
 	  }
   break;
-case 724:
-  case_724();
-  break;
-case 725:
-  case_725();
-  break;
 case 726:
   case_726();
   break;
@@ -3277,11 +3279,11 @@ case 727:
 case 728:
   case_728();
   break;
-case 731:
-  case_731();
+case 729:
+  case_729();
   break;
-case 732:
-  case_732();
+case 730:
+  case_730();
   break;
 case 733:
   case_733();
@@ -3290,34 +3292,34 @@ case 734:
   case_734();
   break;
 case 735:
-#line 4738 "cs-parser.jay"
+  case_735();
+  break;
+case 736:
+  case_736();
+  break;
+case 737:
+#line 4744 "cs-parser.jay"
   {
 		yyVal = new ComposedCast ((FullNamedExpression) yyVals[-1+yyTop], (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
   break;
-case 736:
-#line 4742 "cs-parser.jay"
+case 738:
+#line 4748 "cs-parser.jay"
   {
 		yyVal = new ComposedCast (new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[-1+yyTop])), (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
   break;
-case 737:
-  case_737();
-  break;
 case 739:
   case_739();
   break;
-case 740:
-#line 4763 "cs-parser.jay"
-  {
-		yyVal = ComposedTypeSpecifier.CreatePointer (GetLocation (yyVals[0+yyTop]));
-	  }
-  break;
 case 741:
   case_741();
   break;
 case 742:
-  case_742();
+#line 4769 "cs-parser.jay"
+  {
+		yyVal = ComposedTypeSpecifier.CreatePointer (GetLocation (yyVals[0+yyTop]));
+	  }
   break;
 case 743:
   case_743();
@@ -3325,158 +3327,158 @@ case 743:
 case 744:
   case_744();
   break;
+case 745:
+  case_745();
+  break;
 case 746:
   case_746();
   break;
-case 747:
-  case_747();
+case 748:
+  case_748();
   break;
-case 752:
-  case_752();
-  break;
-case 753:
-  case_753();
+case 749:
+  case_749();
   break;
 case 754:
-#line 4852 "cs-parser.jay"
-  {
-		report.Error (145, lexer.Location, "A const field requires a value to be provided");
-	  }
+  case_754();
   break;
 case 755:
   case_755();
   break;
-case 760:
-  case_760();
+case 756:
+#line 4858 "cs-parser.jay"
+  {
+		report.Error (145, lexer.Location, "A const field requires a value to be provided");
+	  }
+  break;
+case 757:
+  case_757();
   break;
 case 762:
   case_762();
   break;
-case 763:
-  case_763();
-  break;
 case 764:
   case_764();
   break;
 case 765:
-#line 4902 "cs-parser.jay"
-  { yyVal = yyVals[-1+yyTop]; }
+  case_765();
   break;
 case 766:
-#line 4906 "cs-parser.jay"
-  { yyVal = yyVals[-1+yyTop]; }
+  case_766();
   break;
 case 767:
-#line 4907 "cs-parser.jay"
+#line 4908 "cs-parser.jay"
   { yyVal = yyVals[-1+yyTop]; }
   break;
 case 768:
-  case_768();
+#line 4912 "cs-parser.jay"
+  { yyVal = yyVals[-1+yyTop]; }
   break;
 case 769:
-  case_769();
+#line 4913 "cs-parser.jay"
+  { yyVal = yyVals[-1+yyTop]; }
   break;
 case 770:
   case_770();
   break;
-case 773:
-  case_773();
+case 771:
+  case_771();
   break;
-case 774:
-  case_774();
+case 772:
+  case_772();
   break;
 case 775:
-#line 4975 "cs-parser.jay"
-  {
-		start_block (GetLocation (yyVals[0+yyTop]));
-	  }
+  case_775();
   break;
 case 776:
   case_776();
   break;
 case 777:
-  case_777();
+#line 4981 "cs-parser.jay"
+  {
+		start_block (GetLocation (yyVals[0+yyTop]));
+	  }
+  break;
+case 778:
+  case_778();
   break;
 case 779:
   case_779();
   break;
-case 780:
-  case_780();
-  break;
 case 781:
   case_781();
   break;
 case 782:
-#line 5019 "cs-parser.jay"
+  case_782();
+  break;
+case 783:
+  case_783();
+  break;
+case 784:
+#line 5025 "cs-parser.jay"
   {
 		current_block = current_block.CreateSwitchBlock (lexer.Location);
 	  }
   break;
-case 783:
-#line 5023 "cs-parser.jay"
+case 785:
+#line 5029 "cs-parser.jay"
   {
 		yyVal = new SwitchSection ((List<SwitchLabel>) yyVals[-2+yyTop], current_block);
 	  }
   break;
-case 784:
-  case_784();
-  break;
-case 785:
-  case_785();
-  break;
 case 786:
   case_786();
   break;
 case 787:
-#line 5052 "cs-parser.jay"
+  case_787();
+  break;
+case 788:
+  case_788();
+  break;
+case 789:
+#line 5058 "cs-parser.jay"
   {
 		yyVal = new SwitchLabel (null, GetLocation (yyVals[0+yyTop]));
 	  }
   break;
-case 792:
-  case_792();
-  break;
-case 793:
-  case_793();
-  break;
 case 794:
   case_794();
   break;
 case 795:
-#line 5091 "cs-parser.jay"
-  {
-		yyVal = yyVals[0+yyTop];
-	  }
+  case_795();
   break;
 case 796:
   case_796();
   break;
 case 797:
-  case_797();
+#line 5097 "cs-parser.jay"
+  {
+		yyVal = yyVals[0+yyTop];
+	  }
   break;
 case 798:
-#line 5119 "cs-parser.jay"
-  { yyVal = new EmptyStatement (lexer.Location); }
+  case_798();
+  break;
+case 799:
+  case_799();
   break;
 case 800:
-  case_800();
+#line 5125 "cs-parser.jay"
+  { yyVal = new EmptyStatement (lexer.Location); }
   break;
-case 801:
-  case_801();
+case 802:
+  case_802();
   break;
 case 803:
-#line 5140 "cs-parser.jay"
-  { yyVal = null; }
+  case_803();
   break;
 case 805:
-#line 5145 "cs-parser.jay"
-  { yyVal = new EmptyStatement (lexer.Location); }
-  break;
-case 809:
-  case_809();
+#line 5146 "cs-parser.jay"
+  { yyVal = null; }
   break;
-case 810:
-  case_810();
+case 807:
+#line 5151 "cs-parser.jay"
+  { yyVal = new EmptyStatement (lexer.Location); }
   break;
 case 811:
   case_811();
@@ -3484,11 +3486,11 @@ case 811:
 case 812:
   case_812();
   break;
-case 819:
-  case_819();
+case 813:
+  case_813();
   break;
-case 820:
-  case_820();
+case 814:
+  case_814();
   break;
 case 821:
   case_821();
@@ -3511,17 +3513,17 @@ case 826:
 case 827:
   case_827();
   break;
-case 830:
-#line 5300 "cs-parser.jay"
-  {
-		yyVal = new TryCatch ((Block) yyVals[-1+yyTop], (List<Catch>) yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]), false);
-	  }
+case 828:
+  case_828();
   break;
-case 831:
-  case_831();
+case 829:
+  case_829();
   break;
 case 832:
-  case_832();
+#line 5306 "cs-parser.jay"
+  {
+		yyVal = new TryCatch ((Block) yyVals[-1+yyTop], (List<Catch>) yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]), false);
+	  }
   break;
 case 833:
   case_833();
@@ -3532,50 +3534,50 @@ case 834:
 case 835:
   case_835();
   break;
-case 838:
-#line 5353 "cs-parser.jay"
-  {
-		yyVal = new Catch ((Block) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
-	  }
+case 836:
+  case_836();
   break;
-case 839:
-  case_839();
+case 837:
+  case_837();
   break;
 case 840:
-#line 5372 "cs-parser.jay"
+#line 5359 "cs-parser.jay"
   {
-		yyVal = yyVals[-1+yyTop];
+		yyVal = new Catch ((Block) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
 case 841:
   case_841();
   break;
 case 842:
-#line 5390 "cs-parser.jay"
+#line 5378 "cs-parser.jay"
   {
-		yyVal = new Checked ((Block) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+		yyVal = yyVals[-1+yyTop];
 	  }
   break;
 case 843:
-#line 5397 "cs-parser.jay"
-  {
-		yyVal = new Unchecked ((Block) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
-	  }
+  case_843();
   break;
 case 844:
-  case_844();
+#line 5396 "cs-parser.jay"
+  {
+		yyVal = new Checked ((Block) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
+	  }
   break;
 case 845:
-#line 5407 "cs-parser.jay"
+#line 5403 "cs-parser.jay"
   {
-		yyVal = new Unsafe ((Block) yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]));
+		yyVal = new Unchecked ((Block) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
   break;
 case 846:
   case_846();
   break;
 case 847:
-  case_847();
+#line 5413 "cs-parser.jay"
+  {
+		yyVal = new Unsafe ((Block) yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]));
+	  }
   break;
 case 848:
   case_848();
@@ -3596,16 +3598,16 @@ case 853:
   case_853();
   break;
 case 854:
-#line 5490 "cs-parser.jay"
-  {
-		report.Error (210, lexer.Location, "You must provide an initializer in a fixed or using statement declaration");
-	  }
+  case_854();
   break;
 case 855:
   case_855();
   break;
 case 856:
-  case_856();
+#line 5496 "cs-parser.jay"
+  {
+		report.Error (210, lexer.Location, "You must provide an initializer in a fixed or using statement declaration");
+	  }
   break;
 case 857:
   case_857();
@@ -3629,16 +3631,13 @@ case 863:
   case_863();
   break;
 case 864:
-#line 5590 "cs-parser.jay"
-  {
-		current_block = new Linq.QueryBlock (current_block, lexer.Location);
-	  }
+  case_864();
   break;
 case 865:
   case_865();
   break;
 case 866:
-#line 5605 "cs-parser.jay"
+#line 5596 "cs-parser.jay"
   {
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
@@ -3647,22 +3646,25 @@ case 867:
   case_867();
   break;
 case 868:
-  case_868();
+#line 5611 "cs-parser.jay"
+  {
+		current_block = new Linq.QueryBlock (current_block, lexer.Location);
+	  }
+  break;
+case 869:
+  case_869();
   break;
 case 870:
   case_870();
   break;
-case 871:
-#line 5650 "cs-parser.jay"
-  {
-	  	current_block = new Linq.QueryBlock (current_block, lexer.Location);
-	  }
-  break;
 case 872:
   case_872();
   break;
 case 873:
-  case_873();
+#line 5656 "cs-parser.jay"
+  {
+	  	current_block = new Linq.QueryBlock (current_block, lexer.Location);
+	  }
   break;
 case 874:
   case_874();
@@ -3670,20 +3672,17 @@ case 874:
 case 875:
   case_875();
   break;
-case 879:
-  case_879();
+case 876:
+  case_876();
   break;
-case 885:
-#line 5709 "cs-parser.jay"
-  {
-	  	current_block = new Linq.QueryBlock (current_block, lexer.Location);
-	  }
+case 877:
+  case_877();
   break;
-case 886:
-  case_886();
+case 881:
+  case_881();
   break;
 case 887:
-#line 5728 "cs-parser.jay"
+#line 5715 "cs-parser.jay"
   {
 	  	current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
@@ -3692,7 +3691,10 @@ case 888:
   case_888();
   break;
 case 889:
-  case_889();
+#line 5734 "cs-parser.jay"
+  {
+	  	current_block = new Linq.QueryBlock (current_block, lexer.Location);
+	  }
   break;
 case 890:
   case_890();
@@ -3715,144 +3717,150 @@ case 895:
 case 896:
   case_896();
   break;
+case 897:
+  case_897();
+  break;
 case 898:
-#line 5872 "cs-parser.jay"
+  case_898();
+  break;
+case 900:
+#line 5878 "cs-parser.jay"
   {
 		yyVal = yyVals[0+yyTop];
 	  }
   break;
-case 899:
-#line 5879 "cs-parser.jay"
+case 901:
+#line 5885 "cs-parser.jay"
   {
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
   break;
-case 900:
-  case_900();
-  break;
 case 902:
   case_902();
   break;
-case 903:
-  case_903();
+case 904:
+  case_904();
   break;
 case 905:
   case_905();
   break;
-case 906:
-  case_906();
-  break;
 case 907:
-#line 5925 "cs-parser.jay"
-  {
-		yyVal = new Linq.OrderByAscending ((Linq.QueryBlock) current_block, (Expression)yyVals[0+yyTop]);	
-	  }
+  case_907();
   break;
 case 908:
   case_908();
   break;
 case 909:
-  case_909();
-  break;
-case 910:
-#line 5942 "cs-parser.jay"
+#line 5931 "cs-parser.jay"
   {
-		yyVal = new Linq.ThenByAscending ((Linq.QueryBlock) current_block, (Expression)yyVals[0+yyTop]);	
+		yyVal = new Linq.OrderByAscending ((Linq.QueryBlock) current_block, (Expression)yyVals[0+yyTop]);	
 	  }
   break;
+case 910:
+  case_910();
+  break;
 case 911:
   case_911();
   break;
 case 912:
-  case_912();
+#line 5948 "cs-parser.jay"
+  {
+		yyVal = new Linq.ThenByAscending ((Linq.QueryBlock) current_block, (Expression)yyVals[0+yyTop]);	
+	  }
+  break;
+case 913:
+  case_913();
   break;
 case 914:
   case_914();
   break;
-case 915:
-  case_915();
+case 916:
+  case_916();
+  break;
+case 917:
+  case_917();
   break;
-case 918:
-  case_918();
+case 920:
+  case_920();
   break;
-case 919:
-  case_919();
+case 921:
+  case_921();
   break;
-case 927:
-#line 6066 "cs-parser.jay"
+case 929:
+#line 6072 "cs-parser.jay"
   {
 		module.DocumentationBuilder.ParsedName = (MemberName) yyVals[0+yyTop];
 	  }
   break;
-case 928:
-#line 6073 "cs-parser.jay"
+case 930:
+#line 6079 "cs-parser.jay"
   {
 		module.DocumentationBuilder.ParsedParameters = (List<DocumentationParameter>)yyVals[0+yyTop];
 	  }
   break;
-case 929:
-  case_929();
+case 931:
+  case_931();
   break;
-case 930:
-  case_930();
+case 932:
+  case_932();
   break;
-case 931:
-#line 6090 "cs-parser.jay"
+case 933:
+#line 6096 "cs-parser.jay"
   {
 		yyVal = new MemberName ((MemberName) yyVals[-2+yyTop], new MemberName (MemberCache.IndexerNameAlias));
 	  }
   break;
-case 932:
-#line 6094 "cs-parser.jay"
+case 934:
+#line 6100 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out;
 	  }
   break;
-case 933:
-  case_933();
-  break;
-case 934:
-  case_934();
-  break;
 case 935:
   case_935();
   break;
 case 936:
   case_936();
   break;
+case 937:
+  case_937();
+  break;
 case 938:
-#line 6130 "cs-parser.jay"
+  case_938();
+  break;
+case 940:
+#line 6136 "cs-parser.jay"
   {
 		yyVal = new MemberName (((MemberName) yyVals[-2+yyTop]), (MemberName) yyVals[0+yyTop]);
 	  }
   break;
-case 940:
-#line 6138 "cs-parser.jay"
+case 942:
+#line 6144 "cs-parser.jay"
   {
 		valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out;
 	  }
   break;
-case 941:
-#line 6142 "cs-parser.jay"
+case 943:
+#line 6148 "cs-parser.jay"
   {
 		yyVal = yyVals[-1+yyTop];
 	  }
   break;
-case 942:
-#line 6149 "cs-parser.jay"
+case 944:
+#line 6155 "cs-parser.jay"
   {
 		yyVal = new List<DocumentationParameter> (0);
 	  }
   break;
-case 944:
-  case_944();
-  break;
-case 945:
-  case_945();
-  break;
 case 946:
   case_946();
   break;
+case 947:
+  case_947();
+  break;
+case 948:
+  case_948();
+  break;
 #line default
         }
         yyTop -= yyLen[yyN];
@@ -3889,7 +3897,7 @@ case 946:
  All more than 3 lines long rules are wrapped into a method
 */
 void case_6()
-#line 387 "cs-parser.jay"
+#line 388 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] != null) {
 			Attributes attrs = (Attributes) yyVals[0+yyTop];
@@ -3899,7 +3907,7 @@ void case_6()
 	  }
 
 void case_8()
-#line 399 "cs-parser.jay"
+#line 400 "cs-parser.jay"
 {
 		if (yyToken == Token.EXTERN_ALIAS)
 			report.Error (439, lexer.Location, "An extern alias declaration must precede all other elements");
@@ -3908,7 +3916,7 @@ void case_8()
 	  }
 
 void case_13()
-#line 419 "cs-parser.jay"
+#line 420 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		string s = lt.Value;
@@ -3924,21 +3932,21 @@ void case_13()
 	  }
 
 void case_17()
-#line 445 "cs-parser.jay"
+#line 446 "cs-parser.jay"
 {
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
 	  }
 
 void case_18()
-#line 450 "cs-parser.jay"
+#line 451 "cs-parser.jay"
 {
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
 	  }
 
 void case_19()
-#line 458 "cs-parser.jay"
+#line 459 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		if (lang_version != LanguageVersion.ISO_1 && lt.Value == "global") {
@@ -3951,21 +3959,21 @@ void case_19()
 		  }
 
 void case_20()
-#line 469 "cs-parser.jay"
+#line 470 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = null;
 	  }
 
 void case_21()
-#line 477 "cs-parser.jay"
+#line 478 "cs-parser.jay"
 {
 		current_namespace.AddUsing ((MemberName) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 		ubag.AddUsing (GetLocation (yyVals[-2+yyTop]), (MemberName) yyVals[-1+yyTop], GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_22()
-#line 490 "cs-parser.jay"
+#line 491 "cs-parser.jay"
 {
 		Attributes attrs = (Attributes) yyVals[-2+yyTop];
 		MemberName name = (MemberName) yyVals[0+yyTop];
@@ -3998,7 +4006,7 @@ void case_22()
 	  }
 
 void case_23()
-#line 521 "cs-parser.jay"
+#line 522 "cs-parser.jay"
 {
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
@@ -4006,7 +4014,7 @@ void case_23()
 	  }
 
 void case_24()
-#line 527 "cs-parser.jay"
+#line 528 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] != null)
 			lbag.AddLocation (current_namespace, GetLocation (yyVals[-9+yyTop]), GetLocation (yyVals[-6+yyTop]), GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
@@ -4021,28 +4029,28 @@ void case_24()
 	  }
 
 void case_25()
-#line 543 "cs-parser.jay"
+#line 544 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		yyVal = new MemberName (lt.Value, lt.Location);
 	  }
 
 void case_26()
-#line 552 "cs-parser.jay"
+#line 549 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		yyVal = new MemberName ((MemberName) yyVals[-2+yyTop], lt.Value, lt.Location);		
 	  }
 
 void case_27()
-#line 557 "cs-parser.jay"
+#line 554 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = new MemberName ("<invalid>", lexer.Location);
 	  }
 
 void case_32()
-#line 575 "cs-parser.jay"
+#line 572 "cs-parser.jay"
 {
 		MemberName name = (MemberName) yyVals[0+yyTop];
 
@@ -4053,7 +4061,7 @@ void case_32()
 	  }
 
 void case_41()
-#line 607 "cs-parser.jay"
+#line 604 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] != null) {
 			TypeContainer ds = (TypeContainer)yyVals[0+yyTop];
@@ -4074,7 +4082,7 @@ void case_41()
 	  }
 
 void case_50()
-#line 657 "cs-parser.jay"
+#line 654 "cs-parser.jay"
 {
 		var sect = (List<Attribute>) yyVals[0+yyTop];
 		yyVal = new Attributes (sect);
@@ -4082,7 +4090,7 @@ void case_50()
 	  }
 
 void case_51()
-#line 663 "cs-parser.jay"
+#line 660 "cs-parser.jay"
 {
 		Attributes attrs = yyVals[-1+yyTop] as Attributes;
 		var sect = (List<Attribute>) yyVals[0+yyTop];
@@ -4091,25 +4099,24 @@ void case_51()
 		else
 			attrs.AddAttributes (sect);
 		yyVal = attrs;
-		lbag.AddLocation (yyVal, savedOpenLocation, savedCloseLocation);
 	  }
 
 void case_52()
-#line 677 "cs-parser.jay"
+#line 673 "cs-parser.jay"
 {
 		lexer.parsing_attribute_section = true;
 		savedOpenLocation = GetLocation (yyVals[0+yyTop]);
 	  }
 
 void case_53()
-#line 682 "cs-parser.jay"
+#line 678 "cs-parser.jay"
 {
 		lexer.parsing_attribute_section = false;
 		yyVal = yyVals[0+yyTop];
 	  }
 
 void case_54()
-#line 690 "cs-parser.jay"
+#line 686 "cs-parser.jay"
 {
 		current_attr_target = (string) yyVals[-1+yyTop];
 		if (current_attr_target == "assembly" || current_attr_target == "module") {
@@ -4118,7 +4125,7 @@ void case_54()
 	  }
 
 void case_55()
-#line 697 "cs-parser.jay"
+#line 693 "cs-parser.jay"
 {
 		/* when attribute target is invalid*/
 		if (current_attr_target == string.Empty)
@@ -4132,21 +4139,21 @@ void case_55()
  	  }
 
 void case_56()
-#line 709 "cs-parser.jay"
+#line 705 "cs-parser.jay"
 {
 		yyVal = yyVals[-2+yyTop];
 		savedCloseLocation = GetLocation (yyVals[0+yyTop]);
 	  }
 
 void case_57()
-#line 717 "cs-parser.jay"
+#line 713 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		yyVal = CheckAttributeTarget (lt.Value, lt.Location);
 	  }
 
 void case_60()
-#line 724 "cs-parser.jay"
+#line 720 "cs-parser.jay"
 {
 		if (yyToken == Token.IDENTIFIER) {
 			Error_SyntaxError (yyToken);
@@ -4158,7 +4165,7 @@ void case_60()
 	  }
 
 void case_62()
-#line 741 "cs-parser.jay"
+#line 737 "cs-parser.jay"
 {
 		var attrs = (List<Attribute>) yyVals[-2+yyTop];
 		attrs.Add ((Attribute) yyVals[0+yyTop]);
@@ -4167,7 +4174,7 @@ void case_62()
 	  }
 
 void case_64()
-#line 755 "cs-parser.jay"
+#line 751 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		MemberName mname = (MemberName) yyVals[-2+yyTop];
@@ -4182,7 +4189,7 @@ void case_64()
 	  }
 
 void case_69()
-#line 785 "cs-parser.jay"
+#line 781 "cs-parser.jay"
 {
 	  	Arguments a = new Arguments (4);
 		a.Add ((Argument) yyVals[0+yyTop]);
@@ -4190,7 +4197,7 @@ void case_69()
 	  }
 
 void case_70()
-#line 791 "cs-parser.jay"
+#line 787 "cs-parser.jay"
 {
 	  	Arguments a = new Arguments (4);
 		a.Add ((Argument) yyVals[0+yyTop]);  
@@ -4198,7 +4205,7 @@ void case_70()
 	  }
 
 void case_71()
-#line 797 "cs-parser.jay"
+#line 793 "cs-parser.jay"
 {
 		Arguments[] o = (Arguments[]) yyVals[-2+yyTop];
 		if (o [1] != null) {
@@ -4215,7 +4222,7 @@ void case_71()
 	  }
 
 void case_72()
-#line 812 "cs-parser.jay"
+#line 808 "cs-parser.jay"
 {
 		Arguments[] o = (Arguments[]) yyVals[-2+yyTop];
 		if (o [1] == null) {
@@ -4227,7 +4234,7 @@ void case_72()
 	  }
 
 void case_76()
-#line 837 "cs-parser.jay"
+#line 833 "cs-parser.jay"
 {
 	  	--lexer.parsing_block;
 	  	var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
@@ -4236,7 +4243,7 @@ void case_76()
 	  }
 
 void case_77()
-#line 847 "cs-parser.jay"
+#line 843 "cs-parser.jay"
 {
 		if (lang_version <= LanguageVersion.V_3)
 			FeatureIsNotAvailable (GetLocation (yyVals[-3+yyTop]), "named argument");
@@ -4249,7 +4256,7 @@ void case_77()
 	  }
 
 void case_95()
-#line 894 "cs-parser.jay"
+#line 890 "cs-parser.jay"
 {
 		report.Error (1519, lexer.Location, "Unexpected symbol `{0}' in class, struct, or interface member declaration",
 			GetSymbolName (yyToken));
@@ -4258,14 +4265,14 @@ void case_95()
 	  }
 
 void case_97()
-#line 911 "cs-parser.jay"
+#line 907 "cs-parser.jay"
 { 
 		MemberName name = MakeName ((MemberName) yyVals[0+yyTop]);
 		push_current_class (new Struct (current_namespace, current_class, name, (Modifiers) yyVals[-4+yyTop], (Attributes) yyVals[-5+yyTop]), yyVals[-3+yyTop]);
 	  }
 
 void case_98()
-#line 917 "cs-parser.jay"
+#line 913 "cs-parser.jay"
 {
 		lexer.ConstraintsParsing = false;
 
@@ -4278,7 +4285,7 @@ void case_98()
 	  }
 
 void case_99()
-#line 928 "cs-parser.jay"
+#line 924 "cs-parser.jay"
 {
 		--lexer.parsing_declaration;	  
 		if (doc_support)
@@ -4286,21 +4293,21 @@ void case_99()
 	  }
 
 void case_100()
-#line 934 "cs-parser.jay"
+#line 930 "cs-parser.jay"
 {
 		lbag.AppendToMember (current_class, GetLocation (yyVals[0+yyTop]));
 		yyVal = pop_current_class ();
 	  }
 
 void case_102()
-#line 946 "cs-parser.jay"
+#line 942 "cs-parser.jay"
 {
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
 	  }
 
 void case_118()
-#line 988 "cs-parser.jay"
+#line 984 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		var mod = (Modifiers) yyVals[-3+yyTop];
@@ -4315,7 +4322,7 @@ void case_118()
 	  }
 
 void case_119()
-#line 1001 "cs-parser.jay"
+#line 997 "cs-parser.jay"
 {
 		if (doc_support) {
 			current_field.DocComment = Lexer.consume_doc_comment ();
@@ -4328,7 +4335,7 @@ void case_119()
 	  }
 
 void case_124()
-#line 1031 "cs-parser.jay"
+#line 1027 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 	  	yyVal = new FieldDeclarator (new SimpleMemberName (lt.Value, lt.Location), (ConstInitializer) yyVals[0+yyTop]);
@@ -4336,7 +4343,7 @@ void case_124()
 	  }
 
 void case_126()
-#line 1044 "cs-parser.jay"
+#line 1040 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		yyVal = new ConstInitializer (current_field, (Expression) yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]));
@@ -4344,14 +4351,14 @@ void case_126()
 	  }
 
 void case_127()
-#line 1050 "cs-parser.jay"
+#line 1046 "cs-parser.jay"
 {
 		report.Error (145, lexer.Location, "A const field requires a value to be provided");
 		yyVal = null;
 	  }
 
 void case_130()
-#line 1065 "cs-parser.jay"
+#line 1061 "cs-parser.jay"
 {
 	  	lexer.parsing_generic_declaration = false;
 
@@ -4366,7 +4373,7 @@ void case_130()
 	  }
 
 void case_131()
-#line 1080 "cs-parser.jay"
+#line 1076 "cs-parser.jay"
 { 
 		if (doc_support) {
 			current_field.DocComment = Lexer.consume_doc_comment ();
@@ -4379,7 +4386,7 @@ void case_131()
 	  }
 
 void case_132()
-#line 1093 "cs-parser.jay"
+#line 1089 "cs-parser.jay"
 { 
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-2+yyTop]), "fixed size buffers");
@@ -4392,7 +4399,7 @@ void case_132()
 	  }
 
 void case_133()
-#line 1104 "cs-parser.jay"
+#line 1100 "cs-parser.jay"
 {
 		if (doc_support) {
 			current_field.DocComment = Lexer.consume_doc_comment ();
@@ -4406,7 +4413,7 @@ void case_133()
 	  }
 
 void case_136()
-#line 1127 "cs-parser.jay"
+#line 1123 "cs-parser.jay"
 {
 	  	++lexer.parsing_block;
 		current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
@@ -4414,7 +4421,7 @@ void case_136()
 	  }
 
 void case_137()
-#line 1133 "cs-parser.jay"
+#line 1129 "cs-parser.jay"
 {
 	  	--lexer.parsing_block;
 		current_field.Initializer = (Expression) yyVals[0+yyTop];
@@ -4424,7 +4431,7 @@ void case_137()
 	  }
 
 void case_142()
-#line 1160 "cs-parser.jay"
+#line 1156 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 	  	yyVal = new FieldDeclarator (new SimpleMemberName (lt.Value, lt.Location), null);
@@ -4432,7 +4439,7 @@ void case_142()
 	  }
 
 void case_144()
-#line 1170 "cs-parser.jay"
+#line 1166 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];	  
@@ -4441,7 +4448,7 @@ void case_144()
 	  }
 
 void case_149()
-#line 1196 "cs-parser.jay"
+#line 1192 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];	  
 		yyVal = new FieldDeclarator (new SimpleMemberName (lt.Value, lt.Location), (ConstInitializer) yyVals[0+yyTop]);
@@ -4449,7 +4456,7 @@ void case_149()
 	  }
 
 void case_151()
-#line 1209 "cs-parser.jay"
+#line 1205 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		yyVal = new ConstInitializer (current_field, (Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
@@ -4457,14 +4464,14 @@ void case_151()
 	  }
 
 void case_152()
-#line 1215 "cs-parser.jay"
+#line 1211 "cs-parser.jay"
 {
 		report.Error (443, lexer.Location, "Value or constant expected");
 		yyVal = null;
 	  }
 
 void case_155()
-#line 1225 "cs-parser.jay"
+#line 1221 "cs-parser.jay"
 {
 		/* It has to be here for the parent to safely restore artificial block*/
 	  	Error_SyntaxError (yyToken);
@@ -4472,7 +4479,7 @@ void case_155()
 	  }
 
 void case_156()
-#line 1234 "cs-parser.jay"
+#line 1230 "cs-parser.jay"
 {
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.NotAllowed;
@@ -4482,7 +4489,7 @@ void case_156()
 	  }
 
 void case_157()
-#line 1242 "cs-parser.jay"
+#line 1238 "cs-parser.jay"
 {
 		Method method = (Method) yyVals[-2+yyTop];
 		method.Block = (ToplevelBlock) yyVals[0+yyTop];
@@ -4498,7 +4505,7 @@ void case_157()
 	  }
 
 void case_160()
-#line 1270 "cs-parser.jay"
+#line 1266 "cs-parser.jay"
 {
 		lexer.ConstraintsParsing = false;
 		valid_param_mod = 0;
@@ -4533,7 +4540,7 @@ void case_160()
 	  }
 
 void case_163()
-#line 1315 "cs-parser.jay"
+#line 1311 "cs-parser.jay"
 {
 		lexer.ConstraintsParsing = false;
 		valid_param_mod = 0;
@@ -4587,7 +4594,7 @@ void case_163()
 	  }
 
 void case_164()
-#line 1370 "cs-parser.jay"
+#line 1366 "cs-parser.jay"
 {
 		MemberName name = (MemberName) yyVals[-3+yyTop];
 		report.Error (1585, name.Location, 
@@ -4605,7 +4612,7 @@ void case_164()
 	  }
 
 void case_169()
-#line 1399 "cs-parser.jay"
+#line 1395 "cs-parser.jay"
 {
 		var pars_list = (List<Parameter>) yyVals[0+yyTop];
 	  	yyVal = new ParametersCompiled (pars_list.ToArray ());
@@ -4613,7 +4620,7 @@ void case_169()
 	  }
 
 void case_170()
-#line 1405 "cs-parser.jay"
+#line 1401 "cs-parser.jay"
 {
 		var pars_list = (List<Parameter>) yyVals[-2+yyTop];
 		pars_list.Add ((Parameter) yyVals[0+yyTop]);
@@ -4622,7 +4629,7 @@ void case_170()
 	  }
 
 void case_171()
-#line 1412 "cs-parser.jay"
+#line 1408 "cs-parser.jay"
 {
 		var pars_list = (List<Parameter>) yyVals[-2+yyTop];
 		pars_list.Add (new ArglistParameter (GetLocation (yyVals[0+yyTop])));
@@ -4630,7 +4637,7 @@ void case_171()
 	  }
 
 void case_172()
-#line 1418 "cs-parser.jay"
+#line 1414 "cs-parser.jay"
 {
 		if (yyVals[-2+yyTop] != null)
 			report.Error (231, ((Parameter) yyVals[-2+yyTop]).Location, "A params parameter must be the last parameter in a formal parameter list");
@@ -4639,7 +4646,7 @@ void case_172()
 	  }
 
 void case_173()
-#line 1425 "cs-parser.jay"
+#line 1421 "cs-parser.jay"
 {
 		if (yyVals[-2+yyTop] != null)
 			report.Error (231, ((Parameter) yyVals[-2+yyTop]).Location, "A params parameter must be the last parameter in a formal parameter list");
@@ -4651,7 +4658,7 @@ void case_173()
 	  }
 
 void case_174()
-#line 1435 "cs-parser.jay"
+#line 1431 "cs-parser.jay"
 {
 		report.Error (257, GetLocation (yyVals[-2+yyTop]), "An __arglist parameter must be the last parameter in a formal parameter list");
 
@@ -4659,7 +4666,7 @@ void case_174()
 	  }
 
 void case_175()
-#line 1441 "cs-parser.jay"
+#line 1437 "cs-parser.jay"
 {
 		report.Error (257, GetLocation (yyVals[-2+yyTop]), "An __arglist parameter must be the last parameter in a formal parameter list");
 
@@ -4670,14 +4677,14 @@ void case_175()
 	  }
 
 void case_178()
-#line 1458 "cs-parser.jay"
+#line 1454 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = ParametersCompiled.EmptyReadOnlyParameters;
 	  }
 
 void case_179()
-#line 1466 "cs-parser.jay"
+#line 1462 "cs-parser.jay"
 {
 		parameters_bucket.Clear ();
 		Parameter p = (Parameter) yyVals[0+yyTop];
@@ -4688,7 +4695,7 @@ void case_179()
 	  }
 
 void case_180()
-#line 1475 "cs-parser.jay"
+#line 1471 "cs-parser.jay"
 {
 		var pars = (List<Parameter>) yyVals[-2+yyTop];
 		Parameter p = (Parameter) yyVals[0+yyTop];
@@ -4708,7 +4715,7 @@ void case_180()
 	  }
 
 void case_181()
-#line 1499 "cs-parser.jay"
+#line 1495 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		yyVal = new Parameter ((FullNamedExpression) yyVals[-1+yyTop], lt.Value, (Parameter.Modifier) yyVals[-2+yyTop], (Attributes) yyVals[-3+yyTop], lt.Location);
@@ -4716,7 +4723,7 @@ void case_181()
 	  }
 
 void case_182()
-#line 1508 "cs-parser.jay"
+#line 1504 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		report.Error (1552, lt.Location, "Array type specifier, [], must appear before parameter name");
@@ -4725,7 +4732,7 @@ void case_182()
 	  }
 
 void case_183()
-#line 1518 "cs-parser.jay"
+#line 1514 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);	  
 	  	Location l = GetLocation (yyVals[0+yyTop]);
@@ -4734,7 +4741,7 @@ void case_183()
 	  }
 
 void case_185()
-#line 1533 "cs-parser.jay"
+#line 1529 "cs-parser.jay"
 {
 	  	--lexer.parsing_block;
 		if (lang_version <= LanguageVersion.V_3) {
@@ -4773,14 +4780,14 @@ void case_185()
 	  }
 
 void case_188()
-#line 1578 "cs-parser.jay"
+#line 1574 "cs-parser.jay"
 {
 		yyVal = yyVals[0+yyTop];
 		parameterModifierLocation = GetLocation (yyVals[0+yyTop]);
 	  }
 
 void case_189()
-#line 1583 "cs-parser.jay"
+#line 1579 "cs-parser.jay"
 {
 		Parameter.Modifier p2 = (Parameter.Modifier)yyVals[0+yyTop];
   		Parameter.Modifier mod = (Parameter.Modifier)yyVals[-1+yyTop] | p2;
@@ -4803,7 +4810,7 @@ void case_189()
 	  }
 
 void case_190()
-#line 1607 "cs-parser.jay"
+#line 1603 "cs-parser.jay"
 {
 	  	if ((valid_param_mod & ParameterModifierType.Ref) == 0)
 	  		Error_ParameterModifierNotValid ("ref", GetLocation (yyVals[0+yyTop]));
@@ -4812,7 +4819,7 @@ void case_190()
 	  }
 
 void case_191()
-#line 1614 "cs-parser.jay"
+#line 1610 "cs-parser.jay"
 {
 	  	if ((valid_param_mod & ParameterModifierType.Out) == 0)
 	  		Error_ParameterModifierNotValid ("out", GetLocation (yyVals[0+yyTop]));
@@ -4821,7 +4828,7 @@ void case_191()
 	  }
 
 void case_192()
-#line 1621 "cs-parser.jay"
+#line 1617 "cs-parser.jay"
 {
 		if ((valid_param_mod & ParameterModifierType.This) == 0)
 	  		Error_ParameterModifierNotValid ("this", GetLocation (yyVals[0+yyTop]));
@@ -4833,14 +4840,14 @@ void case_192()
 	  }
 
 void case_193()
-#line 1634 "cs-parser.jay"
+#line 1630 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		yyVal = new ParamsParameter ((FullNamedExpression) yyVals[-1+yyTop], lt.Value, (Attributes) yyVals[-3+yyTop], lt.Location);
 	  }
 
 void case_194()
-#line 1639 "cs-parser.jay"
+#line 1635 "cs-parser.jay"
 {
 		report.Error (1751, GetLocation (yyVals[-4+yyTop]), "Cannot specify a default value for a parameter array");
 		
@@ -4849,21 +4856,21 @@ void case_194()
 	  }
 
 void case_195()
-#line 1646 "cs-parser.jay"
+#line 1642 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = null;
 	  }
 
 void case_196()
-#line 1654 "cs-parser.jay"
+#line 1650 "cs-parser.jay"
 {
 		if ((valid_param_mod & ParameterModifierType.Params) == 0)
 			report.Error (1670, (GetLocation (yyVals[0+yyTop])), "The `params' modifier is not allowed in current context");
 	  }
 
 void case_197()
-#line 1659 "cs-parser.jay"
+#line 1655 "cs-parser.jay"
 {
 		Parameter.Modifier mod = (Parameter.Modifier)yyVals[0+yyTop];
 		if ((mod & Parameter.Modifier.This) != 0) {
@@ -4874,21 +4881,21 @@ void case_197()
 	  }
 
 void case_199()
-#line 1675 "cs-parser.jay"
+#line 1671 "cs-parser.jay"
 {
 	  	if ((valid_param_mod & ParameterModifierType.Arglist) == 0)
 	  		report.Error (1669, GetLocation (yyVals[0+yyTop]), "__arglist is not valid in this context");
 	  }
 
 void case_200()
-#line 1686 "cs-parser.jay"
+#line 1682 "cs-parser.jay"
 {
 		if (doc_support)
 			tmpComment = Lexer.consume_doc_comment ();
 	  }
 
 void case_201()
-#line 1691 "cs-parser.jay"
+#line 1687 "cs-parser.jay"
 {
 		var type = (FullNamedExpression) yyVals[-3+yyTop];
 		current_property = new Property (current_class, type, (Modifiers) yyVals[-4+yyTop],
@@ -4904,7 +4911,7 @@ void case_201()
 	  }
 
 void case_202()
-#line 1705 "cs-parser.jay"
+#line 1701 "cs-parser.jay"
 {
 		lexer.PropertyParsing = false;
 		
@@ -4913,14 +4920,14 @@ void case_202()
 	  }
 
 void case_203()
-#line 1712 "cs-parser.jay"
+#line 1708 "cs-parser.jay"
 {
 		lbag.AppendToMember (current_property, GetLocation (yyVals[0+yyTop]));
 		current_property = null;
 	  }
 
 void case_205()
-#line 1726 "cs-parser.jay"
+#line 1722 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 		var type = (FullNamedExpression) yyVals[-6+yyTop];
@@ -4935,7 +4942,7 @@ void case_205()
 		if (type.Type != null && type.Type.Kind == MemberKind.Void)
 			report.Error (620, GetLocation (yyVals[-6+yyTop]), "`{0}': indexer return type cannot be `void'", indexer.GetSignatureForError ());  		
 
-		if (indexer.Parameters.IsEmpty) {
+		if (indexer.ParameterInfo.IsEmpty) {
 			report.Error (1551, GetLocation (yyVals[-4+yyTop]), "Indexers must have at least one parameter");
 		}
 
@@ -4948,7 +4955,7 @@ void case_205()
 	  }
 
 void case_207()
-#line 1756 "cs-parser.jay"
+#line 1752 "cs-parser.jay"
 { 
 		if (doc_support)
 			current_property.DocComment = ConsumeStoredComment ();
@@ -4958,7 +4965,7 @@ void case_207()
 	  }
 
 void case_212()
-#line 1772 "cs-parser.jay"
+#line 1768 "cs-parser.jay"
 {
 	  	if (yyToken == Token.CLOSE_BRACE) {
 	  		report.Error (548, lexer.Location, "`{0}': property or indexer must have at least one accessor", current_property.GetSignatureForError ());
@@ -4971,7 +4978,7 @@ void case_212()
 	  }
 
 void case_213()
-#line 1786 "cs-parser.jay"
+#line 1782 "cs-parser.jay"
 {
 		if (yyVals[-1+yyTop] != ModifierNone && lang_version == LanguageVersion.ISO_1) {
 			FeatureIsNotAvailable (GetLocation (yyVals[-1+yyTop]), "access modifiers on properties");
@@ -4995,7 +5002,7 @@ void case_213()
 	  }
 
 void case_214()
-#line 1808 "cs-parser.jay"
+#line 1804 "cs-parser.jay"
 {
 	  	if (yyVals[0+yyTop] != null) {
 	  		current_property.Get.Block = (ToplevelBlock) yyVals[0+yyTop];			
@@ -5015,7 +5022,7 @@ void case_214()
 	  }
 
 void case_215()
-#line 1829 "cs-parser.jay"
+#line 1825 "cs-parser.jay"
 {
 		if (yyVals[-1+yyTop] != ModifierNone && lang_version == LanguageVersion.ISO_1) {
 			FeatureIsNotAvailable (GetLocation (yyVals[-1+yyTop]), "access modifiers on properties");
@@ -5044,7 +5051,7 @@ void case_215()
 	  }
 
 void case_216()
-#line 1856 "cs-parser.jay"
+#line 1852 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] != null) {		
 			current_property.Set.Block = (ToplevelBlock) yyVals[0+yyTop];
@@ -5064,21 +5071,21 @@ void case_216()
 	  }
 
 void case_218()
-#line 1878 "cs-parser.jay"
+#line 1874 "cs-parser.jay"
 {
 		lbag.AppendToMember (lbag.LastMember, GetLocation (yyVals[0+yyTop]));
 	  	yyVal = null;
 	  }
 
 void case_219()
-#line 1883 "cs-parser.jay"
+#line 1879 "cs-parser.jay"
 {
 	  	Error_SyntaxError (1043, yyToken, "Invalid accessor body");
 	  	yyVal = null;
 	  }
 
 void case_221()
-#line 1898 "cs-parser.jay"
+#line 1894 "cs-parser.jay"
 {
 		MemberName name = MakeName ((MemberName) yyVals[0+yyTop]);
 		push_current_class (new Interface (current_namespace, current_class, name, (Modifiers) yyVals[-4+yyTop], (Attributes) yyVals[-5+yyTop]), yyVals[-3+yyTop]);
@@ -5086,7 +5093,7 @@ void case_221()
 	  }
 
 void case_222()
-#line 1905 "cs-parser.jay"
+#line 1901 "cs-parser.jay"
 {
 		lexer.ConstraintsParsing = false;
 
@@ -5099,7 +5106,7 @@ void case_222()
 	  }
 
 void case_223()
-#line 1916 "cs-parser.jay"
+#line 1912 "cs-parser.jay"
 {
 		--lexer.parsing_declaration;	  
 		if (doc_support)
@@ -5107,14 +5114,14 @@ void case_223()
 	  }
 
 void case_224()
-#line 1922 "cs-parser.jay"
+#line 1918 "cs-parser.jay"
 {
 	    lbag.AppendToMember (current_class, GetLocation (yyVals[-4+yyTop]), GetLocation (yyVals[-2+yyTop]));
 		yyVal = pop_current_class ();
 	  }
 
 void case_240()
-#line 1974 "cs-parser.jay"
+#line 1970 "cs-parser.jay"
 {
 		OperatorDeclaration decl = (OperatorDeclaration) yyVals[-2+yyTop];
 		if (decl != null) {
@@ -5138,14 +5145,14 @@ void case_240()
 	  }
 
 void case_244()
-#line 2005 "cs-parser.jay"
+#line 2001 "cs-parser.jay"
 {
 		report.Error (590, GetLocation (yyVals[0+yyTop]), "User-defined operators cannot return void");
 		yyVal = new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_246()
-#line 2017 "cs-parser.jay"
+#line 2013 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 
@@ -5187,7 +5194,7 @@ void case_246()
 	  }
 
 void case_271()
-#line 2093 "cs-parser.jay"
+#line 2089 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 
@@ -5204,7 +5211,7 @@ void case_271()
 	  }
 
 void case_273()
-#line 2112 "cs-parser.jay"
+#line 2108 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 		
@@ -5221,7 +5228,7 @@ void case_273()
 	  }
 
 void case_274()
-#line 2127 "cs-parser.jay"
+#line 2123 "cs-parser.jay"
 {
 	  	Error_SyntaxError (yyToken);
 		current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
@@ -5229,7 +5236,7 @@ void case_274()
 	  }
 
 void case_275()
-#line 2133 "cs-parser.jay"
+#line 2129 "cs-parser.jay"
 {
 	  	Error_SyntaxError (yyToken);
 		current_local_parameters = ParametersCompiled.EmptyReadOnlyParameters;
@@ -5237,7 +5244,7 @@ void case_275()
 	  }
 
 void case_276()
-#line 2143 "cs-parser.jay"
+#line 2139 "cs-parser.jay"
 { 
 		Constructor c = (Constructor) yyVals[-1+yyTop];
 		c.Block = (ToplevelBlock) yyVals[0+yyTop];
@@ -5253,7 +5260,7 @@ void case_276()
 	  }
 
 void case_277()
-#line 2162 "cs-parser.jay"
+#line 2158 "cs-parser.jay"
 {
 		if (doc_support) {
 			tmpComment = Lexer.consume_doc_comment ();
@@ -5264,7 +5271,7 @@ void case_277()
 	  }
 
 void case_278()
-#line 2171 "cs-parser.jay"
+#line 2167 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 		current_local_parameters = (ParametersCompiled) yyVals[-1+yyTop];  
@@ -5277,7 +5284,7 @@ void case_278()
 	  }
 
 void case_279()
-#line 2182 "cs-parser.jay"
+#line 2178 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-6+yyTop];
 		var mods = (Modifiers) yyVals[-7+yyTop];
@@ -5307,7 +5314,7 @@ void case_279()
 	  }
 
 void case_285()
-#line 2227 "cs-parser.jay"
+#line 2223 "cs-parser.jay"
 {
 	  	--lexer.parsing_block;
 		yyVal = new ConstructorBaseInitializer ((Arguments) yyVals[-1+yyTop], GetLocation (yyVals[-4+yyTop]));
@@ -5315,7 +5322,7 @@ void case_285()
 	  }
 
 void case_287()
-#line 2237 "cs-parser.jay"
+#line 2233 "cs-parser.jay"
 {
 	  	--lexer.parsing_block;
 		yyVal = new ConstructorThisInitializer ((Arguments) yyVals[-1+yyTop], GetLocation (yyVals[-4+yyTop]));
@@ -5323,14 +5330,14 @@ void case_287()
 	  }
 
 void case_288()
-#line 2243 "cs-parser.jay"
+#line 2239 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = null;
 	  }
 
 void case_289()
-#line 2251 "cs-parser.jay"
+#line 2247 "cs-parser.jay"
 {
 		if (doc_support) {
 			tmpComment = Lexer.consume_doc_comment ();
@@ -5341,7 +5348,7 @@ void case_289()
 	  }
 
 void case_290()
-#line 2260 "cs-parser.jay"
+#line 2256 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		if (lt.Value != current_container.MemberName.Name){
@@ -5363,7 +5370,7 @@ void case_290()
 	  }
 
 void case_291()
-#line 2285 "cs-parser.jay"
+#line 2281 "cs-parser.jay"
 {
 		current_event_field = new EventField (current_class, (FullNamedExpression) yyVals[-1+yyTop], (Modifiers) yyVals[-3+yyTop], (MemberName) yyVals[0+yyTop], (Attributes) yyVals[-4+yyTop]);
 		current_container.AddEvent (current_event_field);
@@ -5377,7 +5384,7 @@ void case_291()
 	  }
 
 void case_292()
-#line 2299 "cs-parser.jay"
+#line 2295 "cs-parser.jay"
 {
 		if (doc_support) {
 			current_event_field.DocComment = Lexer.consume_doc_comment ();
@@ -5389,7 +5396,7 @@ void case_292()
 	  }
 
 void case_293()
-#line 2312 "cs-parser.jay"
+#line 2308 "cs-parser.jay"
 {
 		current_event = new EventProperty (current_class, (FullNamedExpression) yyVals[-2+yyTop], (Modifiers) yyVals[-4+yyTop], (MemberName) yyVals[-1+yyTop], (Attributes) yyVals[-5+yyTop]);
 		current_container.AddEvent (current_event);
@@ -5399,7 +5406,7 @@ void case_293()
 	  }
 
 void case_294()
-#line 2320 "cs-parser.jay"
+#line 2316 "cs-parser.jay"
 {
 		if (current_container.Kind == MemberKind.Interface)
 			report.Error (69, GetLocation (yyVals[-2+yyTop]), "Event in interface cannot have add or remove accessors");
@@ -5408,7 +5415,7 @@ void case_294()
 	  }
 
 void case_295()
-#line 2327 "cs-parser.jay"
+#line 2323 "cs-parser.jay"
 {
 		if (doc_support) {
 			current_event.DocComment = Lexer.consume_doc_comment ();
@@ -5421,14 +5428,14 @@ void case_295()
 	  }
 
 void case_298()
-#line 2346 "cs-parser.jay"
+#line 2342 "cs-parser.jay"
 {
 	  	--lexer.parsing_block;
 		current_event_field.Initializer = (Expression) yyVals[0+yyTop];
 	  }
 
 void case_303()
-#line 2370 "cs-parser.jay"
+#line 2366 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 	  	yyVal = new FieldDeclarator (new SimpleMemberName (lt.Value, lt.Location), null);
@@ -5436,7 +5443,7 @@ void case_303()
 	  }
 
 void case_305()
-#line 2380 "cs-parser.jay"
+#line 2376 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];	  
@@ -5445,7 +5452,7 @@ void case_305()
 	  }
 
 void case_306()
-#line 2389 "cs-parser.jay"
+#line 2385 "cs-parser.jay"
 {
 		if (current_container.Kind == MemberKind.Interface) {
 			report.Error (68, lexer.Location, "`{0}': event in interface cannot have an initializer",
@@ -5459,28 +5466,28 @@ void case_306()
 	  }
 
 void case_310()
-#line 2410 "cs-parser.jay"
+#line 2406 "cs-parser.jay"
 {
 		report.Error (65, lexer.Location, "`{0}': event property must have both add and remove accessors",
 			current_event.GetSignatureForError ());
 	  }
 
 void case_311()
-#line 2415 "cs-parser.jay"
+#line 2411 "cs-parser.jay"
 {
 		report.Error (65, lexer.Location, "`{0}': event property must have both add and remove accessors",
 			current_event.GetSignatureForError ());
 	  }
 
 void case_312()
-#line 2420 "cs-parser.jay"
+#line 2416 "cs-parser.jay"
 { 
 		report.Error (1055, GetLocation (yyVals[0+yyTop]), "An add or remove accessor expected");
 		yyVal = null;
 	  }
 
 void case_313()
-#line 2428 "cs-parser.jay"
+#line 2424 "cs-parser.jay"
 {
 	  	if (yyVals[-1+yyTop] != ModifierNone) {
 			report.Error (1609, GetLocation (yyVals[-1+yyTop]), "Modifiers cannot be placed on event accessor declarations");
@@ -5494,7 +5501,7 @@ void case_313()
 	  }
 
 void case_314()
-#line 2440 "cs-parser.jay"
+#line 2436 "cs-parser.jay"
 {
 		lexer.EventParsing = true;
 	  
@@ -5509,7 +5516,7 @@ void case_314()
 	  }
 
 void case_315()
-#line 2456 "cs-parser.jay"
+#line 2452 "cs-parser.jay"
 {
 	  	if (yyVals[-1+yyTop] != ModifierNone) {
 			report.Error (1609, GetLocation (yyVals[-1+yyTop]), "Modifiers cannot be placed on event accessor declarations");
@@ -5523,7 +5530,7 @@ void case_315()
 	  }
 
 void case_316()
-#line 2468 "cs-parser.jay"
+#line 2464 "cs-parser.jay"
 {
 		lexer.EventParsing = true;
 	  
@@ -5538,21 +5545,21 @@ void case_316()
 	  }
 
 void case_317()
-#line 2484 "cs-parser.jay"
+#line 2480 "cs-parser.jay"
 {
 		report.Error (73, lexer.Location, "An add or remove accessor must have a body");
 		yyVal = null;
 	  }
 
 void case_319()
-#line 2496 "cs-parser.jay"
+#line 2492 "cs-parser.jay"
 {
 		if (doc_support)
 			enumTypeComment = Lexer.consume_doc_comment ();
 	  }
 
 void case_320()
-#line 2501 "cs-parser.jay"
+#line 2497 "cs-parser.jay"
 {
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
@@ -5566,7 +5573,7 @@ void case_320()
 	  }
 
 void case_321()
-#line 2513 "cs-parser.jay"
+#line 2509 "cs-parser.jay"
 {
 	  	/* here will be evaluated after CLOSE_BLACE is consumed.*/
 		if (doc_support)
@@ -5574,7 +5581,7 @@ void case_321()
 	  }
 
 void case_322()
-#line 2519 "cs-parser.jay"
+#line 2515 "cs-parser.jay"
 {
 		if (doc_support)
 			current_class.DocComment = enumTypeComment;
@@ -5589,7 +5596,7 @@ void case_322()
 	  }
 
 void case_324()
-#line 2536 "cs-parser.jay"
+#line 2532 "cs-parser.jay"
 {
 	 	var te = yyVals[0+yyTop] as TypeExpression;
 		if (te == null || !EnumSpec.IsValidUnderlyingType (te.Type)) {
@@ -5601,21 +5608,21 @@ void case_324()
 	 }
 
 void case_325()
-#line 2546 "cs-parser.jay"
+#line 2542 "cs-parser.jay"
 {
 	 	Error_TypeExpected (GetLocation (yyVals[-1+yyTop]));
 		yyVal = null;
 	 }
 
 void case_330()
-#line 2564 "cs-parser.jay"
+#line 2560 "cs-parser.jay"
 {
 	  	lbag.AddLocation (yyVals[-2+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  	yyVal = yyVals[0+yyTop];
 	  }
 
 void case_331()
-#line 2572 "cs-parser.jay"
+#line 2568 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 	  	var em = new EnumMember ((Enum) current_class, new MemberName (lt.Value, lt.Location), (Attributes) yyVals[-1+yyTop]);
@@ -5630,7 +5637,7 @@ void case_331()
 	  }
 
 void case_332()
-#line 2585 "cs-parser.jay"
+#line 2581 "cs-parser.jay"
 {
 	  	++lexer.parsing_block;
 		if (doc_support) {
@@ -5640,7 +5647,7 @@ void case_332()
 	  }
 
 void case_333()
-#line 2593 "cs-parser.jay"
+#line 2589 "cs-parser.jay"
 { 
 		--lexer.parsing_block;
 		
@@ -5656,7 +5663,7 @@ void case_333()
 	  }
 
 void case_335()
-#line 2618 "cs-parser.jay"
+#line 2614 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 
@@ -5674,7 +5681,7 @@ void case_335()
 	  }
 
 void case_337()
-#line 2638 "cs-parser.jay"
+#line 2634 "cs-parser.jay"
 {
 		if (doc_support) {
 			current_delegate.DocComment = Lexer.consume_doc_comment ();
@@ -5690,7 +5697,7 @@ void case_337()
 	  }
 
 void case_339()
-#line 2656 "cs-parser.jay"
+#line 2652 "cs-parser.jay"
 {
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[0+yyTop]), "nullable types");
@@ -5699,7 +5706,7 @@ void case_339()
 	  }
 
 void case_341()
-#line 2667 "cs-parser.jay"
+#line 2663 "cs-parser.jay"
 {
 		var lt1 = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		var lt2 = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
@@ -5708,7 +5715,7 @@ void case_341()
 	  }
 
 void case_343()
-#line 2678 "cs-parser.jay"
+#line 2674 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new MemberName ((MemberName) yyVals[-3+yyTop], lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
@@ -5716,14 +5723,14 @@ void case_343()
 	  }
 
 void case_344()
-#line 2687 "cs-parser.jay"
+#line 2683 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new MemberName (lt.Value, (TypeArguments)yyVals[0+yyTop], lt.Location);	  
 	  }
 
 void case_346()
-#line 2699 "cs-parser.jay"
+#line 2695 "cs-parser.jay"
 {
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-2+yyTop]), "generics");	  
@@ -5732,14 +5739,14 @@ void case_346()
 	  }
 
 void case_347()
-#line 2706 "cs-parser.jay"
+#line 2702 "cs-parser.jay"
 {
 		Error_TypeExpected (lexer.Location);
 		yyVal = new TypeArguments ();
 	  }
 
 void case_348()
-#line 2714 "cs-parser.jay"
+#line 2710 "cs-parser.jay"
 {
 		TypeArguments type_args = new TypeArguments ();
 		type_args.Add ((FullNamedExpression) yyVals[0+yyTop]);
@@ -5747,7 +5754,7 @@ void case_348()
 	  }
 
 void case_349()
-#line 2720 "cs-parser.jay"
+#line 2716 "cs-parser.jay"
 {
 		TypeArguments type_args = (TypeArguments) yyVals[-2+yyTop];
 		type_args.Add ((FullNamedExpression) yyVals[0+yyTop]);
@@ -5755,7 +5762,7 @@ void case_349()
 	  }
 
 void case_351()
-#line 2736 "cs-parser.jay"
+#line 2732 "cs-parser.jay"
 {
 		lexer.parsing_generic_declaration = false;
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
@@ -5763,7 +5770,7 @@ void case_351()
 	  }
 
 void case_352()
-#line 2745 "cs-parser.jay"
+#line 2741 "cs-parser.jay"
 {
 	  	MemberName mn = (MemberName)yyVals[0+yyTop];
 	  	if (mn.TypeArguments != null)
@@ -5772,7 +5779,7 @@ void case_352()
 	  }
 
 void case_354()
-#line 2756 "cs-parser.jay"
+#line 2752 "cs-parser.jay"
 {
 		lexer.parsing_generic_declaration = false;	  
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
@@ -5780,21 +5787,21 @@ void case_354()
 	  }
 
 void case_355()
-#line 2765 "cs-parser.jay"
+#line 2761 "cs-parser.jay"
 {
 		lexer.parsing_generic_declaration = false;	  
 		yyVal = new MemberName (TypeContainer.DefaultIndexerName, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_356()
-#line 2770 "cs-parser.jay"
+#line 2766 "cs-parser.jay"
 {
 		lexer.parsing_generic_declaration = false;
 		yyVal = new MemberName ((MemberName) yyVals[-1+yyTop], TypeContainer.DefaultIndexerName, null, GetLocation (yyVals[-1+yyTop]));
 	  }
 
 void case_357()
-#line 2778 "cs-parser.jay"
+#line 2774 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		yyVal = new MemberName (lt.Value, (TypeArguments) yyVals[-1+yyTop], lt.Location);
@@ -5802,7 +5809,7 @@ void case_357()
 	  }
 
 void case_358()
-#line 2784 "cs-parser.jay"
+#line 2780 "cs-parser.jay"
 {
 		var lt1 = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		var lt2 = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
@@ -5812,7 +5819,7 @@ void case_358()
 	  }
 
 void case_359()
-#line 2792 "cs-parser.jay"
+#line 2788 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		yyVal = new MemberName ((MemberName) yyVals[-3+yyTop], lt.Value, (TypeArguments) yyVals[-1+yyTop], lt.Location);
@@ -5820,7 +5827,7 @@ void case_359()
 	  }
 
 void case_361()
-#line 2802 "cs-parser.jay"
+#line 2798 "cs-parser.jay"
 {
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-2+yyTop]), "generics");
@@ -5830,7 +5837,7 @@ void case_361()
 	  }
 
 void case_362()
-#line 2813 "cs-parser.jay"
+#line 2809 "cs-parser.jay"
 {
 		TypeArguments type_args = new TypeArguments ();
 		type_args.Add ((FullNamedExpression)yyVals[0+yyTop]);
@@ -5838,7 +5845,7 @@ void case_362()
 	  }
 
 void case_363()
-#line 2819 "cs-parser.jay"
+#line 2815 "cs-parser.jay"
 {
 		TypeArguments type_args = (TypeArguments) yyVals[-2+yyTop];
 		type_args.Add ((FullNamedExpression)yyVals[0+yyTop]);
@@ -5847,14 +5854,14 @@ void case_363()
 	  }
 
 void case_364()
-#line 2829 "cs-parser.jay"
+#line 2825 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken)yyVals[0+yyTop];
 		yyVal = new TypeParameterName (lt.Value, (Attributes)yyVals[-2+yyTop], (Variance) yyVals[-1+yyTop], lt.Location);
   	  }
 
 void case_365()
-#line 2834 "cs-parser.jay"
+#line 2830 "cs-parser.jay"
 {
   	  	if (GetTokenName (yyToken) == "type")
 			report.Error (81, GetLocation (yyVals[0+yyTop]), "Type parameter declaration must be an identifier not a type");
@@ -5865,28 +5872,28 @@ void case_365()
   	  }
 
 void case_370()
-#line 2868 "cs-parser.jay"
+#line 2864 "cs-parser.jay"
 {
 	  	Expression.Error_VoidInvalidInTheContext (GetLocation (yyVals[0+yyTop]), report);
 		yyVal = new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_372()
-#line 2877 "cs-parser.jay"
+#line 2873 "cs-parser.jay"
 {
 	  	Expression.Error_VoidInvalidInTheContext (GetLocation (yyVals[0+yyTop]), report);
 		yyVal = new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_374()
-#line 2886 "cs-parser.jay"
+#line 2882 "cs-parser.jay"
 {
 	  	report.Error (1536, GetLocation (yyVals[0+yyTop]), "Invalid parameter type `void'");
 		yyVal = new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_377()
-#line 2902 "cs-parser.jay"
+#line 2898 "cs-parser.jay"
 {
 		MemberName name = (MemberName) yyVals[-1+yyTop];
 
@@ -5901,14 +5908,14 @@ void case_377()
 	  }
 
 void case_379()
-#line 2919 "cs-parser.jay"
+#line 2915 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] != null)
 			yyVal = new ComposedCast ((FullNamedExpression) yyVals[-1+yyTop], (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
 
 void case_382()
-#line 2935 "cs-parser.jay"
+#line 2931 "cs-parser.jay"
 {
 		var types = new List<FullNamedExpression> (2);
 		types.Add ((FullNamedExpression) yyVals[0+yyTop]);
@@ -5916,7 +5923,7 @@ void case_382()
 	  }
 
 void case_383()
-#line 2941 "cs-parser.jay"
+#line 2937 "cs-parser.jay"
 {
 		var types = (List<FullNamedExpression>) yyVals[-2+yyTop];
 		types.Add ((FullNamedExpression) yyVals[0+yyTop]);
@@ -5924,7 +5931,7 @@ void case_383()
 	  }
 
 void case_384()
-#line 2950 "cs-parser.jay"
+#line 2946 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is ComposedCast) {
 			report.Error (1521, GetLocation (yyVals[0+yyTop]), "Invalid base type `{0}'", ((ComposedCast)yyVals[0+yyTop]).GetSignatureForError ());
@@ -5933,35 +5940,35 @@ void case_384()
 	  }
 
 void case_385()
-#line 2957 "cs-parser.jay"
+#line 2953 "cs-parser.jay"
 {
 	  	Error_TypeExpected (lexer.Location);
 		yyVal = null;
 	  }
 
 void case_422()
-#line 3019 "cs-parser.jay"
+#line 3015 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new SimpleName (lt.Value, (TypeArguments)yyVals[0+yyTop], lt.Location);	  
 	  }
 
 void case_423()
-#line 3023 "cs-parser.jay"
+#line 3019 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 	       yyVal = new CompletionSimpleName (MemberName.MakeName (lt.Value, null), lt.Location);
 	  }
 
 void case_434()
-#line 3064 "cs-parser.jay"
+#line 3060 "cs-parser.jay"
 {
 		yyVal = new ParenthesizedExpression ((Expression) yyVals[-1+yyTop]);
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_436()
-#line 3076 "cs-parser.jay"
+#line 3072 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new MemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
@@ -5969,7 +5976,7 @@ void case_436()
 	  }
 
 void case_437()
-#line 3082 "cs-parser.jay"
+#line 3078 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new MemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
@@ -5977,7 +5984,7 @@ void case_437()
 	  }
 
 void case_438()
-#line 3088 "cs-parser.jay"
+#line 3084 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new MemberAccess (new BaseThis (GetLocation (yyVals[-3+yyTop])), lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
@@ -5985,37 +5992,38 @@ void case_438()
 	  }
 
 void case_439()
-#line 3094 "cs-parser.jay"
+#line 3090 "cs-parser.jay"
 {
 		var lt1 = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		var lt2 = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 
 		yyVal = new QualifiedAliasMember (lt1.Value, lt2.Value, (TypeArguments) yyVals[0+yyTop], lt1.Location);
+		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
 void case_441()
-#line 3103 "cs-parser.jay"
+#line 3100 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new CompletionMemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, lt.Location);
 	  }
 
 void case_443()
-#line 3111 "cs-parser.jay"
+#line 3108 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new CompletionMemberAccess ((Expression) yyVals[-3+yyTop], lt.Value, lt.Location);
  	  }
 
 void case_444()
-#line 3119 "cs-parser.jay"
+#line 3116 "cs-parser.jay"
 {
 		yyVal = new Invocation ((Expression) yyVals[-3+yyTop], (Arguments) yyVals[-1+yyTop]);
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_447()
-#line 3132 "cs-parser.jay"
+#line 3129 "cs-parser.jay"
 {
 	  	if (yyVals[-1+yyTop] == null) {
 	  		yyVal = CollectionOrObjectInitializers.Empty;
@@ -6027,14 +6035,14 @@ void case_447()
 	  }
 
 void case_448()
-#line 3142 "cs-parser.jay"
+#line 3139 "cs-parser.jay"
 {
 	  	yyVal = new CollectionOrObjectInitializers ((List<Expression>) yyVals[-2+yyTop], GetLocation (yyVals[-3+yyTop]));
 	  	lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_451()
-#line 3158 "cs-parser.jay"
+#line 3155 "cs-parser.jay"
 {
 	  	var a = new List<Expression> ();
 	  	a.Add ((Expression) yyVals[0+yyTop]);
@@ -6042,7 +6050,7 @@ void case_451()
 	  }
 
 void case_452()
-#line 3164 "cs-parser.jay"
+#line 3161 "cs-parser.jay"
 {
 	  	var a = (List<Expression>)yyVals[-2+yyTop];
 	  	a.Add ((Expression) yyVals[0+yyTop]);
@@ -6050,14 +6058,14 @@ void case_452()
 	  }
 
 void case_453()
-#line 3169 "cs-parser.jay"
+#line 3166 "cs-parser.jay"
 {
 	  	Error_SyntaxError (yyToken);
 		yyVal = yyVals[-1+yyTop];
 	  }
 
 void case_454()
-#line 3177 "cs-parser.jay"
+#line 3174 "cs-parser.jay"
 {
 	  	var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 	  	yyVal = new ElementInitializer (lt.Value, (Expression)yyVals[0+yyTop], lt.Location);
@@ -6065,7 +6073,7 @@ void case_454()
 	  }
 
 void case_456()
-#line 3186 "cs-parser.jay"
+#line 3183 "cs-parser.jay"
 {
 		CompletionSimpleName csn = yyVals[-1+yyTop] as CompletionSimpleName;
 		if (csn == null)
@@ -6075,7 +6083,7 @@ void case_456()
 	  }
 
 void case_457()
-#line 3194 "cs-parser.jay"
+#line 3191 "cs-parser.jay"
 {
 		if (yyVals[-1+yyTop] == null)
 			yyVal = null;
@@ -6084,14 +6092,14 @@ void case_457()
 	  }
 
 void case_458()
-#line 3201 "cs-parser.jay"
+#line 3198 "cs-parser.jay"
 {
 	  	report.Error (1920, GetLocation (yyVals[-1+yyTop]), "An element initializer cannot be empty");
 		yyVal = null;
 	  }
 
 void case_463()
-#line 3219 "cs-parser.jay"
+#line 3216 "cs-parser.jay"
 { 
 		Arguments list = new Arguments (4);
 		list.Add ((Argument) yyVals[0+yyTop]);
@@ -6099,7 +6107,7 @@ void case_463()
 	  }
 
 void case_464()
-#line 3225 "cs-parser.jay"
+#line 3222 "cs-parser.jay"
 {
 		Arguments list = (Arguments) yyVals[-2+yyTop];
 		if (list [list.Count - 1] is NamedArgument)
@@ -6111,7 +6119,7 @@ void case_464()
 	  }
 
 void case_465()
-#line 3235 "cs-parser.jay"
+#line 3232 "cs-parser.jay"
 {
 		Arguments list = (Arguments) yyVals[-2+yyTop];
 		NamedArgument a = (NamedArgument) yyVals[0+yyTop];
@@ -6128,56 +6136,56 @@ void case_465()
 	  }
 
 void case_466()
-#line 3250 "cs-parser.jay"
+#line 3247 "cs-parser.jay"
 {
 	  	report.Error (839, GetLocation (yyVals[0+yyTop]), "An argument is missing");
 	  	yyVal = yyVals[-1+yyTop];
 	  }
 
 void case_467()
-#line 3255 "cs-parser.jay"
+#line 3252 "cs-parser.jay"
 {
 	  	report.Error (839, GetLocation (yyVals[-1+yyTop]), "An argument is missing");
 	  	yyVal = null;
 	  }
 
 void case_472()
-#line 3276 "cs-parser.jay"
+#line 3273 "cs-parser.jay"
 { 
 		yyVal = new Argument ((Expression) yyVals[0+yyTop], Argument.AType.Ref);
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
 void case_473()
-#line 3281 "cs-parser.jay"
+#line 3278 "cs-parser.jay"
 { 
 		yyVal = new Argument ((Expression) yyVals[0+yyTop], Argument.AType.Out);
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
 void case_474()
-#line 3286 "cs-parser.jay"
+#line 3283 "cs-parser.jay"
 {
 		yyVal = new Argument (new Arglist ((Arguments) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop])));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_475()
-#line 3291 "cs-parser.jay"
+#line 3288 "cs-parser.jay"
 {
 		yyVal = new Argument (new Arglist (GetLocation (yyVals[-2+yyTop])));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_477()
-#line 3303 "cs-parser.jay"
+#line 3300 "cs-parser.jay"
 {
 		yyVal = new ElementAccess ((Expression) yyVals[-3+yyTop], (Arguments) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_478()
-#line 3311 "cs-parser.jay"
+#line 3308 "cs-parser.jay"
 {
 		var list = new List<Expression> (4);
 		list.Add ((Expression) yyVals[0+yyTop]);
@@ -6185,7 +6193,7 @@ void case_478()
 	  }
 
 void case_479()
-#line 3317 "cs-parser.jay"
+#line 3314 "cs-parser.jay"
 {
 		var list = (List<Expression>) yyVals[-2+yyTop];
 		list.Add ((Expression) yyVals[0+yyTop]);
@@ -6194,14 +6202,14 @@ void case_479()
 	  }
 
 void case_480()
-#line 3323 "cs-parser.jay"
+#line 3320 "cs-parser.jay"
 {
 	  	Error_SyntaxError (yyToken);
 		yyVal = yyVals[-1+yyTop];
 	  }
 
 void case_481()
-#line 3331 "cs-parser.jay"
+#line 3328 "cs-parser.jay"
 {
 		Arguments args = new Arguments (4);
 		args.Add ((Argument) yyVals[0+yyTop]);
@@ -6209,7 +6217,7 @@ void case_481()
 	  }
 
 void case_482()
-#line 3337 "cs-parser.jay"
+#line 3334 "cs-parser.jay"
 {
 		Arguments args = (Arguments) yyVals[-2+yyTop];
 		if (args [args.Count - 1] is NamedArgument && !(yyVals[0+yyTop] is NamedArgument))
@@ -6221,21 +6229,21 @@ void case_482()
 	  }
 
 void case_486()
-#line 3365 "cs-parser.jay"
+#line 3362 "cs-parser.jay"
 {
 	  	yyVal = new ElementAccess (new BaseThis (GetLocation (yyVals[-3+yyTop])), (Arguments) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_487()
-#line 3370 "cs-parser.jay"
+#line 3367 "cs-parser.jay"
 {
 	  	Error_SyntaxError (yyToken);
 		yyVal = new ElementAccess (null, null, GetLocation (yyVals[-1+yyTop]));
 	  }
 
 void case_490()
-#line 3392 "cs-parser.jay"
+#line 3389 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] != null) {
 			if (lang_version <= LanguageVersion.ISO_2)
@@ -6250,7 +6258,7 @@ void case_490()
 	  }
 
 void case_491()
-#line 3405 "cs-parser.jay"
+#line 3402 "cs-parser.jay"
 {
 		if (lang_version <= LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-2+yyTop]), "collection initializers");
@@ -6259,7 +6267,7 @@ void case_491()
 	  }
 
 void case_492()
-#line 3417 "cs-parser.jay"
+#line 3414 "cs-parser.jay"
 {
 		yyVal = new ArrayCreation ((FullNamedExpression) yyVals[-5+yyTop], (List<Expression>) yyVals[-3+yyTop],
 				new ComposedTypeSpecifier (((List<Expression>) yyVals[-3+yyTop]).Count, GetLocation (yyVals[-4+yyTop])) {
@@ -6269,7 +6277,7 @@ void case_492()
 	  }
 
 void case_493()
-#line 3425 "cs-parser.jay"
+#line 3422 "cs-parser.jay"
 {
 	  	if (yyVals[0+yyTop] == null)
 	  		report.Error (1586, GetLocation (yyVals[-3+yyTop]), "Array creation must have array size or array initializer");
@@ -6278,7 +6286,7 @@ void case_493()
 	  }
 
 void case_494()
-#line 3432 "cs-parser.jay"
+#line 3429 "cs-parser.jay"
 {
 		if (lang_version <= LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-2+yyTop]), "implicitly typed arrays");
@@ -6287,28 +6295,28 @@ void case_494()
 	  }
 
 void case_495()
-#line 3439 "cs-parser.jay"
+#line 3436 "cs-parser.jay"
 {
 		report.Error (178, GetLocation (yyVals[-1+yyTop]), "Invalid rank specifier, expecting `,' or `]'");
 		yyVal = new ArrayCreation ((FullNamedExpression) yyVals[-5+yyTop], null, GetLocation (yyVals[-6+yyTop]));
 	  }
 
 void case_496()
-#line 3444 "cs-parser.jay"
+#line 3441 "cs-parser.jay"
 {
 		Error_SyntaxError (1526, yyToken, "Unexpected symbol");
 		yyVal = new ArrayCreation ((FullNamedExpression) yyVals[-1+yyTop], null, GetLocation (yyVals[-2+yyTop]));
 	  }
 
 void case_498()
-#line 3455 "cs-parser.jay"
+#line 3452 "cs-parser.jay"
 {
 		--lexer.parsing_type;
 		yyVal = yyVals[0+yyTop];
 	  }
 
 void case_499()
-#line 3463 "cs-parser.jay"
+#line 3460 "cs-parser.jay"
 {
 		if (lang_version <= LanguageVersion.ISO_2)
 	  		FeatureIsNotAvailable (GetLocation (yyVals[-3+yyTop]), "anonymous types");
@@ -6320,7 +6328,7 @@ void case_499()
 	  }
 
 void case_504()
-#line 3486 "cs-parser.jay"
+#line 3483 "cs-parser.jay"
 {
 	  	var a = new List<AnonymousTypeParameter> (4);
 	  	a.Add ((AnonymousTypeParameter) yyVals[0+yyTop]);
@@ -6328,7 +6336,7 @@ void case_504()
 	  }
 
 void case_505()
-#line 3492 "cs-parser.jay"
+#line 3489 "cs-parser.jay"
 {
 	  	var a = (List<AnonymousTypeParameter>) yyVals[-2+yyTop];
 	  	a.Add ((AnonymousTypeParameter) yyVals[0+yyTop]);
@@ -6336,7 +6344,7 @@ void case_505()
 	  }
 
 void case_506()
-#line 3501 "cs-parser.jay"
+#line 3498 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken)yyVals[-2+yyTop];
 	  	yyVal = new AnonymousTypeParameter ((Expression)yyVals[0+yyTop], lt.Value, lt.Location);
@@ -6344,7 +6352,7 @@ void case_506()
 	  }
 
 void case_507()
-#line 3507 "cs-parser.jay"
+#line 3504 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken)yyVals[0+yyTop];
 	  	yyVal = new AnonymousTypeParameter (new SimpleName (lt.Value, lt.Location),
@@ -6352,14 +6360,14 @@ void case_507()
 	  }
 
 void case_508()
-#line 3513 "cs-parser.jay"
+#line 3510 "cs-parser.jay"
 {
 	  	MemberAccess ma = (MemberAccess) yyVals[0+yyTop];
 	  	yyVal = new AnonymousTypeParameter (ma, ma.Name, ma.Location);
 	  }
 
 void case_509()
-#line 3518 "cs-parser.jay"
+#line 3515 "cs-parser.jay"
 {
 		report.Error (746, lexer.Location,
 			"Invalid anonymous type member declarator. Anonymous type members must be a member assignment, simple name or member access expression");
@@ -6367,28 +6375,28 @@ void case_509()
 	  }
 
 void case_513()
-#line 3533 "cs-parser.jay"
+#line 3530 "cs-parser.jay"
 {
 	  	((ComposedTypeSpecifier) yyVals[-1+yyTop]).Next = (ComposedTypeSpecifier) yyVals[0+yyTop];
 	  	yyVal = yyVals[-1+yyTop];
 	  }
 
 void case_514()
-#line 3541 "cs-parser.jay"
+#line 3538 "cs-parser.jay"
 {
 		yyVal = ComposedTypeSpecifier.CreateArrayDimension (1, GetLocation (yyVals[-1+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_515()
-#line 3546 "cs-parser.jay"
+#line 3543 "cs-parser.jay"
 {
 		yyVal = ComposedTypeSpecifier.CreateArrayDimension ((int)yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_520()
-#line 3576 "cs-parser.jay"
+#line 3573 "cs-parser.jay"
 {
 		var ai = new ArrayInitializer (0, GetLocation (yyVals[-1+yyTop]));
 		ai.VariableDeclaration = current_variable;
@@ -6397,7 +6405,7 @@ void case_520()
 	  }
 
 void case_521()
-#line 3583 "cs-parser.jay"
+#line 3580 "cs-parser.jay"
 {
 		var ai = new ArrayInitializer ((List<Expression>) yyVals[-2+yyTop], GetLocation (yyVals[-3+yyTop]));
 		ai.VariableDeclaration = current_variable;
@@ -6410,7 +6418,7 @@ void case_521()
 	  }
 
 void case_522()
-#line 3597 "cs-parser.jay"
+#line 3594 "cs-parser.jay"
 {
 		var list = new List<Expression> (4);
 		list.Add ((Expression) yyVals[0+yyTop]);
@@ -6418,7 +6426,7 @@ void case_522()
 	  }
 
 void case_523()
-#line 3603 "cs-parser.jay"
+#line 3600 "cs-parser.jay"
 {
 		var list = (List<Expression>) yyVals[-2+yyTop];
 		list.Add ((Expression) yyVals[0+yyTop]);
@@ -6427,7 +6435,7 @@ void case_523()
 	  }
 
 void case_525()
-#line 3617 "cs-parser.jay"
+#line 3614 "cs-parser.jay"
 {
 	  	lexer.TypeOfParsing = false;
 		yyVal = new TypeOf ((FullNamedExpression) yyVals[-1+yyTop], GetLocation (yyVals[-4+yyTop]));
@@ -6435,14 +6443,14 @@ void case_525()
 	  }
 
 void case_528()
-#line 3628 "cs-parser.jay"
+#line 3625 "cs-parser.jay"
 {
 	 	Error_TypeExpected (lexer.Location);
 	 	yyVal = null;
 	 }
 
 void case_529()
-#line 3636 "cs-parser.jay"
+#line 3633 "cs-parser.jay"
 {  
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 
@@ -6450,16 +6458,17 @@ void case_529()
 	  }
 
 void case_530()
-#line 3642 "cs-parser.jay"
+#line 3639 "cs-parser.jay"
 {
 		var lt1 = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		var lt2 = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 
 		yyVal = new QualifiedAliasMember (lt1.Value, lt2.Value, (int) yyVals[0+yyTop], lt1.Location);
+		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
 void case_531()
-#line 3649 "cs-parser.jay"
+#line 3647 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		
@@ -6467,7 +6476,7 @@ void case_531()
 	  }
 
 void case_532()
-#line 3655 "cs-parser.jay"
+#line 3653 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		
@@ -6475,7 +6484,7 @@ void case_532()
 	  }
 
 void case_533()
-#line 3661 "cs-parser.jay"
+#line 3659 "cs-parser.jay"
 {
 		var te = ((MemberName) yyVals[-3+yyTop]).GetTypeExpression ();
 		if (te.HasTypeArguments)
@@ -6486,7 +6495,7 @@ void case_533()
 	  }
 
 void case_534()
-#line 3673 "cs-parser.jay"
+#line 3671 "cs-parser.jay"
 {
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[0+yyTop]), "generics");
@@ -6495,7 +6504,7 @@ void case_534()
 	  }
 
 void case_535()
-#line 3683 "cs-parser.jay"
+#line 3681 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		if (lang_version == LanguageVersion.ISO_1)
@@ -6505,35 +6514,35 @@ void case_535()
 	  }
 
 void case_536()
-#line 3694 "cs-parser.jay"
+#line 3692 "cs-parser.jay"
 { 
 		yyVal = new SizeOf ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_537()
-#line 3702 "cs-parser.jay"
+#line 3700 "cs-parser.jay"
 {
 		yyVal = new CheckedExpr ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_538()
-#line 3710 "cs-parser.jay"
+#line 3708 "cs-parser.jay"
 {
 		yyVal = new UnCheckedExpr ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
 void case_539()
-#line 3718 "cs-parser.jay"
+#line 3716 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new MemberAccess (new Indirection ((Expression) yyVals[-3+yyTop], GetLocation (yyVals[-2+yyTop])), lt.Value, (TypeArguments) yyVals[0+yyTop], lt.Location);
 	  }
 
 void case_541()
-#line 3730 "cs-parser.jay"
+#line 3728 "cs-parser.jay"
 {
 		yyVal = end_anonymous ((ParametersBlock) yyVals[0+yyTop]);
 		if ((ParametersCompiled) yyVals[-2+yyTop] != ParametersCompiled.Undefined) {
@@ -6544,7 +6553,7 @@ void case_541()
 	  }
 
 void case_545()
-#line 3754 "cs-parser.jay"
+#line 3752 "cs-parser.jay"
 {
 		valid_param_mod = 0;
 	  	yyVal = yyVals[-1+yyTop];
@@ -6553,7 +6562,7 @@ void case_545()
 	  }
 
 void case_546()
-#line 3764 "cs-parser.jay"
+#line 3762 "cs-parser.jay"
 {
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-3+yyTop]), "default value expression");
@@ -6562,141 +6571,141 @@ void case_546()
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_551()
-#line 3788 "cs-parser.jay"
+void case_552()
+#line 3787 "cs-parser.jay"
 {
 		yyVal = new Cast ((FullNamedExpression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_560()
-#line 3829 "cs-parser.jay"
+void case_562()
+#line 3835 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.Multiply, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_561()
-#line 3834 "cs-parser.jay"
+void case_563()
+#line 3840 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.Division, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_562()
-#line 3839 "cs-parser.jay"
+void case_564()
+#line 3845 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.Modulus, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_564()
-#line 3848 "cs-parser.jay"
+void case_566()
+#line 3854 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.Addition, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_566()
-#line 3857 "cs-parser.jay"
+void case_568()
+#line 3863 "cs-parser.jay"
 {
 	  	/* Shift/Reduce conflict*/
 		yyVal = new Binary (Binary.Operator.Subtraction, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
   	  }
 
-void case_570()
-#line 3874 "cs-parser.jay"
+void case_572()
+#line 3880 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.LeftShift, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_571()
-#line 3879 "cs-parser.jay"
+void case_573()
+#line 3885 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.RightShift, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_573()
-#line 3888 "cs-parser.jay"
+void case_575()
+#line 3894 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.LessThan, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_574()
-#line 3893 "cs-parser.jay"
+void case_576()
+#line 3899 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.GreaterThan, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_575()
-#line 3898 "cs-parser.jay"
+void case_577()
+#line 3904 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.LessThanOrEqual, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_576()
-#line 3903 "cs-parser.jay"
+void case_578()
+#line 3909 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.GreaterThanOrEqual, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_578()
-#line 3912 "cs-parser.jay"
+void case_580()
+#line 3918 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.Equality, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_579()
-#line 3917 "cs-parser.jay"
+void case_581()
+#line 3923 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.Inequality, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_581()
-#line 3926 "cs-parser.jay"
+void case_583()
+#line 3932 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.BitwiseAnd, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_583()
-#line 3935 "cs-parser.jay"
+void case_585()
+#line 3941 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.ExclusiveOr, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_585()
-#line 3944 "cs-parser.jay"
+void case_587()
+#line 3950 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.BitwiseOr, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_587()
-#line 3953 "cs-parser.jay"
+void case_589()
+#line 3959 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.LogicalAnd, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_589()
-#line 3962 "cs-parser.jay"
+void case_591()
+#line 3968 "cs-parser.jay"
 {
 		yyVal = new Binary (Binary.Operator.LogicalOr, 
 			         (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_591()
-#line 3971 "cs-parser.jay"
+void case_593()
+#line 3977 "cs-parser.jay"
 {
 		if (lang_version < LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[-1+yyTop]), "null coalescing operator");
@@ -6704,85 +6713,85 @@ void case_591()
 		yyVal = new Nullable.NullCoalescingOperator ((Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_593()
-#line 3982 "cs-parser.jay"
+void case_595()
+#line 3988 "cs-parser.jay"
 {
 		yyVal = new Conditional (new BooleanExpression ((Expression) yyVals[-4+yyTop]), (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_595()
-#line 3994 "cs-parser.jay"
+void case_597()
+#line 4000 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.Multiply, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_596()
-#line 3999 "cs-parser.jay"
+void case_598()
+#line 4005 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.Division, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_597()
-#line 4004 "cs-parser.jay"
+void case_599()
+#line 4010 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.Modulus, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_598()
-#line 4009 "cs-parser.jay"
+void case_600()
+#line 4015 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.Addition, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_599()
-#line 4014 "cs-parser.jay"
+void case_601()
+#line 4020 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.Subtraction, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_600()
-#line 4019 "cs-parser.jay"
+void case_602()
+#line 4025 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.LeftShift, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_601()
-#line 4024 "cs-parser.jay"
+void case_603()
+#line 4030 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.RightShift, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_602()
-#line 4029 "cs-parser.jay"
+void case_604()
+#line 4035 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.BitwiseAnd, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_603()
-#line 4034 "cs-parser.jay"
+void case_605()
+#line 4040 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.BitwiseOr, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_604()
-#line 4039 "cs-parser.jay"
+void case_606()
+#line 4045 "cs-parser.jay"
 {
 		yyVal = new CompoundAssign (
 			Binary.Operator.ExclusiveOr, (Expression) yyVals[-2+yyTop], (Expression) yyVals[0+yyTop], GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_605()
-#line 4047 "cs-parser.jay"
+void case_607()
+#line 4053 "cs-parser.jay"
 {
 		var pars = new List<Parameter> (4);
 		pars.Add ((Parameter) yyVals[0+yyTop]);
@@ -6790,8 +6799,8 @@ void case_605()
 		yyVal = pars;
 	  }
 
-void case_606()
-#line 4054 "cs-parser.jay"
+void case_608()
+#line 4060 "cs-parser.jay"
 {
 		var pars = (List<Parameter>) yyVals[-2+yyTop];
 		Parameter p = (Parameter)yyVals[0+yyTop];
@@ -6803,38 +6812,38 @@ void case_606()
 		yyVal = pars;
 	  }
 
-void case_607()
-#line 4068 "cs-parser.jay"
+void case_609()
+#line 4074 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 
 		yyVal = new Parameter ((FullNamedExpression) yyVals[-1+yyTop], lt.Value, (Parameter.Modifier) yyVals[-2+yyTop], null, lt.Location);
 	  }
 
-void case_608()
-#line 4074 "cs-parser.jay"
+void case_610()
+#line 4080 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 
 		yyVal = new Parameter ((FullNamedExpression) yyVals[-1+yyTop], lt.Value, Parameter.Modifier.NONE, null, lt.Location);
 	  }
 
-void case_609()
-#line 4080 "cs-parser.jay"
+void case_611()
+#line 4086 "cs-parser.jay"
 {
 	  	var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		yyVal = new ImplicitLambdaParameter (lt.Value, lt.Location);
 	  }
 
-void case_611()
-#line 4088 "cs-parser.jay"
+void case_613()
+#line 4094 "cs-parser.jay"
 { 
 		var pars_list = (List<Parameter>) yyVals[0+yyTop];
 		yyVal = new ParametersCompiled (pars_list.ToArray ());
 	  }
 
-void case_615()
-#line 4104 "cs-parser.jay"
+void case_617()
+#line 4110 "cs-parser.jay"
 {
 		Block b = end_block (lexer.Location);
 		b.IsCompilerGenerated = true;
@@ -6842,30 +6851,30 @@ void case_615()
 		yyVal = b;
 	  }
 
-void case_617()
-#line 4115 "cs-parser.jay"
+void case_619()
+#line 4121 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);	
 		yyVal = EmptyExpression.Null;
 	  }
 
-void case_618()
-#line 4123 "cs-parser.jay"
+void case_620()
+#line 4129 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		Parameter p = new ImplicitLambdaParameter (lt.Value, lt.Location);
 		start_anonymous (true, new ParametersCompiled (p), GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_619()
-#line 4129 "cs-parser.jay"
+void case_621()
+#line 4135 "cs-parser.jay"
 {
 		yyVal = end_anonymous ((ParametersBlock) yyVals[0+yyTop]);
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]));
 	  }
 
-void case_620()
-#line 4134 "cs-parser.jay"
+void case_622()
+#line 4140 "cs-parser.jay"
 {
 		if (lang_version <= LanguageVersion.ISO_2)
 			FeatureIsNotAvailable (GetLocation (yyVals[0+yyTop]), "lambda expressions");
@@ -6873,43 +6882,43 @@ void case_620()
 	  	valid_param_mod = ParameterModifierType.Ref | ParameterModifierType.Out;
 	  }
 
-void case_621()
-#line 4141 "cs-parser.jay"
+void case_623()
+#line 4147 "cs-parser.jay"
 {
 	  	valid_param_mod = 0;
 		start_anonymous (true, (ParametersCompiled) yyVals[-2+yyTop], GetLocation (yyVals[-4+yyTop]));
 	  }
 
-void case_622()
-#line 4146 "cs-parser.jay"
+void case_624()
+#line 4152 "cs-parser.jay"
 {
 		yyVal = end_anonymous ((ParametersBlock) yyVals[0+yyTop]);
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-2+yyTop]));
 	  }
 
-void case_629()
-#line 4169 "cs-parser.jay"
+void case_631()
+#line 4175 "cs-parser.jay"
 {
 		yyVal = new RefValueExpr ((Expression) yyVals[-3+yyTop], (FullNamedExpression) yyVals[-1+yyTop], GetLocation (yyVals[-5+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-4+yyTop]), GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_630()
-#line 4174 "cs-parser.jay"
+void case_632()
+#line 4180 "cs-parser.jay"
 {
 		yyVal = new RefTypeExpr ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_631()
-#line 4179 "cs-parser.jay"
+void case_633()
+#line 4185 "cs-parser.jay"
 {
 		yyVal = new MakeRefExpr ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));	  
 	  }
 
-void case_635()
-#line 4208 "cs-parser.jay"
+void case_637()
+#line 4214 "cs-parser.jay"
 {
 		MemberName name = MakeName ((MemberName) yyVals[0+yyTop]);
 		Class c = new Class (current_namespace, current_class, name, (Modifiers) yyVals[-4+yyTop], (Attributes) yyVals[-5+yyTop]);
@@ -6920,8 +6929,8 @@ void case_635()
 		push_current_class (c, yyVals[-3+yyTop]);
 	  }
 
-void case_636()
-#line 4219 "cs-parser.jay"
+void case_638()
+#line 4225 "cs-parser.jay"
 {
 		lexer.ConstraintsParsing = false;
 
@@ -6934,30 +6943,30 @@ void case_636()
 		}
 	  }
 
-void case_637()
-#line 4231 "cs-parser.jay"
+void case_639()
+#line 4237 "cs-parser.jay"
 {
 		--lexer.parsing_declaration;
 		if (doc_support)
 			Lexer.doc_state = XmlCommentState.Allowed;
 	  }
 
-void case_638()
-#line 4237 "cs-parser.jay"
+void case_640()
+#line 4243 "cs-parser.jay"
 {
 		lbag.AppendToMember (current_class, GetLocation (yyVals[-4+yyTop]), GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 		yyVal = pop_current_class ();
 	  }
 
-void case_641()
-#line 4252 "cs-parser.jay"
+void case_643()
+#line 4258 "cs-parser.jay"
 {
 	    mod_locations = null;
 		yyVal = ModifierNone;
 	  }
 
-void case_644()
-#line 4262 "cs-parser.jay"
+void case_646()
+#line 4268 "cs-parser.jay"
 { 
 		var m1 = (Modifiers) yyVals[-1+yyTop];
 		var m2 = (Modifiers) yyVals[0+yyTop];
@@ -6974,8 +6983,8 @@ void case_644()
 		yyVal = m1 | m2;
 	  }
 
-void case_645()
-#line 4281 "cs-parser.jay"
+void case_647()
+#line 4287 "cs-parser.jay"
 {
 		yyVal = Modifiers.NEW;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
@@ -6984,92 +6993,92 @@ void case_645()
 			report.Error (1530, GetLocation (yyVals[0+yyTop]), "Keyword `new' is not allowed on namespace elements");
 	  }
 
-void case_646()
-#line 4289 "cs-parser.jay"
+void case_648()
+#line 4295 "cs-parser.jay"
 {
 		yyVal = Modifiers.PUBLIC;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_647()
-#line 4294 "cs-parser.jay"
+void case_649()
+#line 4300 "cs-parser.jay"
 {
 		yyVal = Modifiers.PROTECTED;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_648()
-#line 4299 "cs-parser.jay"
+void case_650()
+#line 4305 "cs-parser.jay"
 {
 		yyVal = Modifiers.INTERNAL;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_649()
-#line 4304 "cs-parser.jay"
+void case_651()
+#line 4310 "cs-parser.jay"
 {
 		yyVal = Modifiers.PRIVATE;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_650()
-#line 4309 "cs-parser.jay"
+void case_652()
+#line 4315 "cs-parser.jay"
 {
 		yyVal = Modifiers.ABSTRACT;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_651()
-#line 4314 "cs-parser.jay"
+void case_653()
+#line 4320 "cs-parser.jay"
 {
 		yyVal = Modifiers.SEALED;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_652()
-#line 4319 "cs-parser.jay"
+void case_654()
+#line 4325 "cs-parser.jay"
 {
 		yyVal = Modifiers.STATIC;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_653()
-#line 4324 "cs-parser.jay"
+void case_655()
+#line 4330 "cs-parser.jay"
 {
 		yyVal = Modifiers.READONLY;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_654()
-#line 4329 "cs-parser.jay"
+void case_656()
+#line 4335 "cs-parser.jay"
 {
 		yyVal = Modifiers.VIRTUAL;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_655()
-#line 4334 "cs-parser.jay"
+void case_657()
+#line 4340 "cs-parser.jay"
 {
 		yyVal = Modifiers.OVERRIDE;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_656()
-#line 4339 "cs-parser.jay"
+void case_658()
+#line 4345 "cs-parser.jay"
 {
 		yyVal = Modifiers.EXTERN;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_657()
-#line 4344 "cs-parser.jay"
+void case_659()
+#line 4350 "cs-parser.jay"
 {
 		yyVal = Modifiers.VOLATILE;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_658()
-#line 4349 "cs-parser.jay"
+void case_660()
+#line 4355 "cs-parser.jay"
 {
 		yyVal = Modifiers.UNSAFE;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
@@ -7077,30 +7086,30 @@ void case_658()
 			Error_UnsafeCodeNotAllowed (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_659()
-#line 4356 "cs-parser.jay"
+void case_661()
+#line 4362 "cs-parser.jay"
 {
 		yyVal = Modifiers.ASYNC;
 		StoreModifierLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_664()
-#line 4377 "cs-parser.jay"
+void case_666()
+#line 4383 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = null;
 	 }
 
-void case_665()
-#line 4385 "cs-parser.jay"
+void case_667()
+#line 4391 "cs-parser.jay"
 {
 		var constraints = new List<Constraints> (1);
 		constraints.Add ((Constraints) yyVals[0+yyTop]);
 		yyVal = constraints;
 	  }
 
-void case_666()
-#line 4391 "cs-parser.jay"
+void case_668()
+#line 4397 "cs-parser.jay"
 {
 		var constraints = (List<Constraints>) yyVals[-1+yyTop];
 		Constraints new_constraint = (Constraints)yyVals[0+yyTop];
@@ -7117,23 +7126,23 @@ void case_666()
 		yyVal = constraints;
 	  }
 
-void case_667()
-#line 4410 "cs-parser.jay"
+void case_669()
+#line 4416 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		yyVal = new Constraints (new SimpleMemberName (lt.Value, lt.Location), (List<FullNamedExpression>) yyVals[0+yyTop], GetLocation (yyVals[-3+yyTop]));
 	  }
 
-void case_668()
-#line 4418 "cs-parser.jay"
+void case_670()
+#line 4424 "cs-parser.jay"
 {
 		var constraints = new List<FullNamedExpression> (1);
 		constraints.Add ((FullNamedExpression) yyVals[0+yyTop]);
 		yyVal = constraints;
 	  }
 
-void case_669()
-#line 4424 "cs-parser.jay"
+void case_671()
+#line 4430 "cs-parser.jay"
 {
 		var constraints = (List<FullNamedExpression>) yyVals[-2+yyTop];
 		var prev = constraints [constraints.Count - 1] as SpecialContraintExpr;
@@ -7157,8 +7166,8 @@ void case_669()
 		yyVal = constraints;
 	  }
 
-void case_670()
-#line 4450 "cs-parser.jay"
+void case_672()
+#line 4456 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is ComposedCast)
 			report.Error (706, GetLocation (yyVals[0+yyTop]), "Invalid constraint type `{0}'", ((ComposedCast)yyVals[0+yyTop]).GetSignatureForError ());
@@ -7166,15 +7175,15 @@ void case_670()
 	  	yyVal = yyVals[0+yyTop];
 	  }
 
-void case_671()
-#line 4457 "cs-parser.jay"
+void case_673()
+#line 4463 "cs-parser.jay"
 {
 		yyVal = new SpecialContraintExpr (SpecialConstraint.Constructor, GetLocation (yyVals[-2+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_675()
-#line 4477 "cs-parser.jay"
+void case_677()
+#line 4483 "cs-parser.jay"
 {
 		if (lang_version <= LanguageVersion.V_3)
 			FeatureIsNotAvailable (lexer.Location, "generic type variance");
@@ -7182,78 +7191,78 @@ void case_675()
 		yyVal = yyVals[0+yyTop];
 	  }
 
-void case_678()
-#line 4511 "cs-parser.jay"
+void case_680()
+#line 4517 "cs-parser.jay"
 {
 		++lexer.parsing_block;
 		start_block (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_680()
-#line 4523 "cs-parser.jay"
+void case_682()
+#line 4529 "cs-parser.jay"
 {
 	 	--lexer.parsing_block;
 		yyVal = end_block (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_681()
-#line 4528 "cs-parser.jay"
+void case_683()
+#line 4534 "cs-parser.jay"
 {
 	 	--lexer.parsing_block;
 		yyVal = end_block (lexer.Location);
 	  }
 
-void case_682()
-#line 4537 "cs-parser.jay"
+void case_684()
+#line 4543 "cs-parser.jay"
 {
 		++lexer.parsing_block;
 		current_block.StartLocation = GetLocation (yyVals[0+yyTop]);
 	  }
 
-void case_683()
-#line 4542 "cs-parser.jay"
+void case_685()
+#line 4548 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		yyVal = end_block (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_691()
-#line 4569 "cs-parser.jay"
+void case_693()
+#line 4575 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = null;
 	  }
 
-void case_724()
-#line 4633 "cs-parser.jay"
+void case_726()
+#line 4639 "cs-parser.jay"
 {
 		  report.Error (1023, GetLocation (yyVals[0+yyTop]), "An embedded statement may not be a declaration or labeled statement");
 		  yyVal = null;
 	  }
 
-void case_725()
-#line 4638 "cs-parser.jay"
+void case_727()
+#line 4644 "cs-parser.jay"
 {
 		  report.Error (1023, GetLocation (yyVals[0+yyTop]), "An embedded statement may not be a declaration or labeled statement");
 		  yyVal = null;
 	  }
 
-void case_726()
-#line 4643 "cs-parser.jay"
+void case_728()
+#line 4649 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = new EmptyStatement (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_727()
-#line 4651 "cs-parser.jay"
+void case_729()
+#line 4657 "cs-parser.jay"
 {
 		/* Uses lexer.Location because semicolon location is not kept in quick mode*/
 		yyVal = new EmptyStatement (lexer.Location);
 	  }
 
-void case_728()
-#line 4659 "cs-parser.jay"
+void case_730()
+#line 4665 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		LabeledStatement labeled = new LabeledStatement (lt.Value, current_block, lt.Location);
@@ -7262,8 +7271,8 @@ void case_728()
 		current_block.AddStatement (labeled);
 	  }
 
-void case_731()
-#line 4672 "cs-parser.jay"
+void case_733()
+#line 4678 "cs-parser.jay"
 {
 		if (yyVals[-1+yyTop] is VarExpr)
 			yyVals[-1+yyTop] = new SimpleName ("var", ((VarExpr) yyVals[-1+yyTop]).Location);
@@ -7271,8 +7280,8 @@ void case_731()
 		yyVal = new ComposedCast ((FullNamedExpression) yyVals[-1+yyTop], (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
 
-void case_732()
-#line 4688 "cs-parser.jay"
+void case_734()
+#line 4694 "cs-parser.jay"
 { 
 		/* Ok, the above "primary_expression" is there to get rid of*/
 		/* both reduce/reduce and shift/reduces in the grammar, it should*/
@@ -7303,8 +7312,8 @@ void case_732()
 		}
 	  }
 
-void case_733()
-#line 4718 "cs-parser.jay"
+void case_735()
+#line 4724 "cs-parser.jay"
 {
 		ATypeNameExpression expr = yyVals[-1+yyTop] as ATypeNameExpression;
 
@@ -7316,8 +7325,8 @@ void case_733()
 		}
 	  }
 
-void case_734()
-#line 4729 "cs-parser.jay"
+void case_736()
+#line 4735 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] == null)
 			yyVal = yyVals[-1+yyTop];
@@ -7325,22 +7334,22 @@ void case_734()
 			yyVal = new ComposedCast ((FullNamedExpression) yyVals[-1+yyTop], (ComposedTypeSpecifier) yyVals[0+yyTop]);
 	  }
 
-void case_737()
-#line 4744 "cs-parser.jay"
+void case_739()
+#line 4750 "cs-parser.jay"
 {
 		Expression.Error_VoidInvalidInTheContext (GetLocation (yyVals[0+yyTop]), report);
 		yyVal = new TypeExpression (compiler.BuiltinTypes.Void, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_739()
-#line 4753 "cs-parser.jay"
+void case_741()
+#line 4759 "cs-parser.jay"
 {
 	  	((ComposedTypeSpecifier) yyVals[-1+yyTop]).Next = (ComposedTypeSpecifier) yyVals[0+yyTop];
 	  	yyVal = yyVals[-1+yyTop];
 	  }
 
-void case_741()
-#line 4768 "cs-parser.jay"
+void case_743()
+#line 4774 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		var li = new LocalVariable (current_block, lt.Value, lt.Location);
@@ -7348,16 +7357,16 @@ void case_741()
 		current_variable = new BlockVariableDeclaration ((FullNamedExpression) yyVals[-1+yyTop], li);
 	  }
 
-void case_742()
-#line 4775 "cs-parser.jay"
+void case_744()
+#line 4781 "cs-parser.jay"
 {
 		yyVal = current_variable;
 		current_variable = null;
 		lbag.AppendTo (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_743()
-#line 4781 "cs-parser.jay"
+void case_745()
+#line 4787 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.Constant, lt.Location);
@@ -7365,8 +7374,8 @@ void case_743()
 		current_variable = new BlockConstantDeclaration ((FullNamedExpression) yyVals[-1+yyTop], li);
 	  }
 
-void case_744()
-#line 4788 "cs-parser.jay"
+void case_746()
+#line 4794 "cs-parser.jay"
 {
 		if (current_variable.Initializer != null) {
 			lbag.AddLocation (current_variable, GetLocation (yyVals[-6+yyTop]), savedLocation, GetLocation (yyVals[0+yyTop]));
@@ -7377,15 +7386,15 @@ void case_744()
 		current_variable = null;
 	  }
 
-void case_746()
-#line 4802 "cs-parser.jay"
+void case_748()
+#line 4808 "cs-parser.jay"
 {
 		current_variable.Initializer = (Expression) yyVals[0+yyTop];
 		lbag.AppendTo (current_variable, GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_747()
-#line 4807 "cs-parser.jay"
+void case_749()
+#line 4813 "cs-parser.jay"
 {
 	  	if (yyToken == Token.OPEN_BRACKET_EXPR) {
 			report.Error (650, lexer.Location,
@@ -7395,8 +7404,8 @@ void case_747()
 		}
 	  }
 
-void case_752()
-#line 4829 "cs-parser.jay"
+void case_754()
+#line 4835 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];	  
 		var li = new LocalVariable (current_variable.Variable, lt.Value, lt.Location);
@@ -7406,8 +7415,8 @@ void case_752()
 	  	lbag.AddLocation (d, GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_753()
-#line 4838 "cs-parser.jay"
+void case_755()
+#line 4844 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];	  
 		var li = new LocalVariable (current_variable.Variable, lt.Value, lt.Location);
@@ -7417,15 +7426,15 @@ void case_753()
 	  	lbag.AddLocation (d, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_755()
-#line 4854 "cs-parser.jay"
+void case_757()
+#line 4860 "cs-parser.jay"
 {
 		savedLocation = GetLocation (yyVals[-1+yyTop]);
 		current_variable.Initializer = (Expression) yyVals[0+yyTop];
 	  }
 
-void case_760()
-#line 4872 "cs-parser.jay"
+void case_762()
+#line 4878 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];	  
 		var li = new LocalVariable (current_block, lt.Value, LocalVariable.Flags.Constant, lt.Location);
@@ -7435,29 +7444,29 @@ void case_760()
 	  	lbag.AddLocation (d, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_762()
-#line 4885 "cs-parser.jay"
+void case_764()
+#line 4891 "cs-parser.jay"
 {
 		yyVal = new StackAlloc ((Expression) yyVals[-3+yyTop], (Expression) yyVals[-1+yyTop], GetLocation (yyVals[-4+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_763()
-#line 4890 "cs-parser.jay"
+void case_765()
+#line 4896 "cs-parser.jay"
 {
 		report.Error (1575, GetLocation (yyVals[-1+yyTop]), "A stackalloc expression requires [] after type");
 		yyVal = new StackAlloc ((Expression) yyVals[0+yyTop], null, GetLocation (yyVals[-1+yyTop]));		
 	  }
 
-void case_764()
-#line 4898 "cs-parser.jay"
+void case_766()
+#line 4904 "cs-parser.jay"
 {
 		yyVal = yyVals[-1+yyTop];
 		lbag.AddStatement (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_768()
-#line 4916 "cs-parser.jay"
+void case_770()
+#line 4922 "cs-parser.jay"
 {
 		ExpressionStatement s = yyVals[0+yyTop] as ExpressionStatement;
 		if (s == null) {
@@ -7468,8 +7477,8 @@ void case_768()
 		yyVal = new StatementExpression (s);
 	  }
 
-void case_769()
-#line 4929 "cs-parser.jay"
+void case_771()
+#line 4935 "cs-parser.jay"
 {
 		Expression expr = (Expression) yyVals[0+yyTop];
 		ExpressionStatement s;
@@ -7478,15 +7487,15 @@ void case_769()
 		yyVal = new StatementExpression (s);
 	  }
 
-void case_770()
-#line 4937 "cs-parser.jay"
+void case_772()
+#line 4943 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = new EmptyStatement (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_773()
-#line 4951 "cs-parser.jay"
+void case_775()
+#line 4957 "cs-parser.jay"
 { 
 		if (yyVals[0+yyTop] is EmptyStatement)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7495,8 +7504,8 @@ void case_773()
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_774()
-#line 4960 "cs-parser.jay"
+void case_776()
+#line 4966 "cs-parser.jay"
 {
 		yyVal = new If ((BooleanExpression) yyVals[-4+yyTop], (Statement) yyVals[-2+yyTop], (Statement) yyVals[0+yyTop], GetLocation (yyVals[-6+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-5+yyTop]), GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
@@ -7507,23 +7516,23 @@ void case_774()
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_776()
-#line 4977 "cs-parser.jay"
+void case_778()
+#line 4983 "cs-parser.jay"
 {
 		yyVal = new Switch ((Expression) yyVals[-5+yyTop], (ExplicitBlock) current_block.Explicit, (List<SwitchSection>) yyVals[-1+yyTop], GetLocation (yyVals[-7+yyTop]));	
 		end_block (GetLocation (yyVals[0+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-6+yyTop]), GetLocation (yyVals[-4+yyTop]), GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_777()
-#line 4986 "cs-parser.jay"
+void case_779()
+#line 4992 "cs-parser.jay"
 {
 		report.Warning (1522, 1, current_block.StartLocation, "Empty switch block"); 
 		yyVal = new List<SwitchSection> ();
 	  }
 
-void case_779()
-#line 4995 "cs-parser.jay"
+void case_781()
+#line 5001 "cs-parser.jay"
 {
 		var sections = new List<SwitchSection> (4);
 
@@ -7531,8 +7540,8 @@ void case_779()
 		yyVal = sections;
 	  }
 
-void case_780()
-#line 5002 "cs-parser.jay"
+void case_782()
+#line 5008 "cs-parser.jay"
 {
 		var sections = (List<SwitchSection>) yyVals[-1+yyTop];
 
@@ -7540,15 +7549,15 @@ void case_780()
 		yyVal = sections;
 	  }
 
-void case_781()
-#line 5009 "cs-parser.jay"
+void case_783()
+#line 5015 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);	  
 		yyVal = new List<SwitchSection> ();
 	  }
 
-void case_784()
-#line 5028 "cs-parser.jay"
+void case_786()
+#line 5034 "cs-parser.jay"
 {
 		var labels = new List<SwitchLabel> (2);
 
@@ -7556,8 +7565,8 @@ void case_784()
 		yyVal = labels;
 	  }
 
-void case_785()
-#line 5035 "cs-parser.jay"
+void case_787()
+#line 5041 "cs-parser.jay"
 {
 		var labels = (List<SwitchLabel>) (yyVals[-1+yyTop]);
 		labels.Add ((SwitchLabel) yyVals[0+yyTop]);
@@ -7565,15 +7574,15 @@ void case_785()
 		yyVal = labels;
 	  }
 
-void case_786()
-#line 5045 "cs-parser.jay"
+void case_788()
+#line 5051 "cs-parser.jay"
 {
 	 	yyVal = new SwitchLabel ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 	 	lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	 }
 
-void case_792()
-#line 5064 "cs-parser.jay"
+void case_794()
+#line 5070 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7582,22 +7591,22 @@ void case_792()
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_793()
-#line 5076 "cs-parser.jay"
+void case_795()
+#line 5082 "cs-parser.jay"
 {
 		yyVal = new Do ((Statement) yyVals[-5+yyTop], (BooleanExpression) yyVals[-2+yyTop], GetLocation (yyVals[-6+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-4+yyTop]), GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_794()
-#line 5084 "cs-parser.jay"
+void case_796()
+#line 5090 "cs-parser.jay"
 {
 		start_block (GetLocation (yyVals[0+yyTop]));
 		current_block.IsCompilerGenerated = true;
 	  }
 
-void case_796()
-#line 5100 "cs-parser.jay"
+void case_798()
+#line 5106 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7610,15 +7619,15 @@ void case_796()
 		yyVal = end_block (GetLocation (yyVals[-5+yyTop]));
 	  }
 
-void case_797()
-#line 5112 "cs-parser.jay"
+void case_799()
+#line 5118 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = end_block (current_block.StartLocation);
 	  }
 
-void case_800()
-#line 5125 "cs-parser.jay"
+void case_802()
+#line 5131 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[0+yyTop];
 		var li = new LocalVariable (current_block, lt.Value, lt.Location);
@@ -7626,15 +7635,15 @@ void case_800()
 		current_variable = new BlockVariableDeclaration ((FullNamedExpression) yyVals[-1+yyTop], li);
 	  }
 
-void case_801()
-#line 5132 "cs-parser.jay"
+void case_803()
+#line 5138 "cs-parser.jay"
 {
 		yyVal = current_variable;
 		current_variable = null;
 	  }
 
-void case_809()
-#line 5156 "cs-parser.jay"
+void case_811()
+#line 5162 "cs-parser.jay"
 {
 	  	var sl = yyVals[-2+yyTop] as StatementList;
 	  	if (sl == null) {
@@ -7648,15 +7657,15 @@ void case_809()
 		yyVal = sl;
 	  }
 
-void case_810()
-#line 5172 "cs-parser.jay"
+void case_812()
+#line 5178 "cs-parser.jay"
 {
 		report.Error (230, GetLocation (yyVals[-5+yyTop]), "Type and identifier are both required in a foreach statement");
 		yyVal = null;
 	  }
 
-void case_811()
-#line 5177 "cs-parser.jay"
+void case_813()
+#line 5183 "cs-parser.jay"
 {
 		start_block (GetLocation (yyVals[-5+yyTop]));
 		current_block.IsCompilerGenerated = true;
@@ -7666,8 +7675,8 @@ void case_811()
 		yyVal = li;
 	  }
 
-void case_812()
-#line 5186 "cs-parser.jay"
+void case_814()
+#line 5192 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7679,58 +7688,58 @@ void case_812()
 		yyVal = end_block (GetLocation (yyVals[-2+yyTop]));
 	  }
 
-void case_819()
-#line 5209 "cs-parser.jay"
+void case_821()
+#line 5215 "cs-parser.jay"
 {
 		yyVal = new Break (GetLocation (yyVals[-1+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_820()
-#line 5217 "cs-parser.jay"
+void case_822()
+#line 5223 "cs-parser.jay"
 {
 		yyVal = new Continue (GetLocation (yyVals[-1+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_821()
-#line 5225 "cs-parser.jay"
+void case_823()
+#line 5231 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-1+yyTop];
 		yyVal = new Goto (lt.Value, GetLocation (yyVals[-2+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_822()
-#line 5231 "cs-parser.jay"
+void case_824()
+#line 5237 "cs-parser.jay"
 {
 		yyVal = new GotoCase ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_823()
-#line 5236 "cs-parser.jay"
+void case_825()
+#line 5242 "cs-parser.jay"
 {
 		yyVal = new GotoDefault (GetLocation (yyVals[-2+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_824()
-#line 5244 "cs-parser.jay"
+void case_826()
+#line 5250 "cs-parser.jay"
 {
 		yyVal = new Return ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_825()
-#line 5252 "cs-parser.jay"
+void case_827()
+#line 5258 "cs-parser.jay"
 {
 		yyVal = new Throw ((Expression) yyVals[-1+yyTop], GetLocation (yyVals[-2+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_826()
-#line 5260 "cs-parser.jay"
+void case_828()
+#line 5266 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		string s = lt.Value;
@@ -7747,8 +7756,8 @@ void case_826()
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-2+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_827()
-#line 5276 "cs-parser.jay"
+void case_829()
+#line 5282 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
 		string s = lt.Value;
@@ -7763,29 +7772,29 @@ void case_827()
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-1+yyTop]), GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_831()
-#line 5302 "cs-parser.jay"
+void case_833()
+#line 5308 "cs-parser.jay"
 {
 		yyVal = new TryFinally ((Statement) yyVals[-2+yyTop], (Block) yyVals[0+yyTop], GetLocation (yyVals[-3+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_832()
-#line 5307 "cs-parser.jay"
+void case_834()
+#line 5313 "cs-parser.jay"
 {
 		yyVal = new TryFinally (new TryCatch ((Block) yyVals[-3+yyTop], (List<Catch>) yyVals[-2+yyTop], GetLocation (yyVals[-4+yyTop]), true), (Block) yyVals[0+yyTop], GetLocation (yyVals[-4+yyTop]));
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_833()
-#line 5312 "cs-parser.jay"
+void case_835()
+#line 5318 "cs-parser.jay"
 {
 		report.Error (1524, GetLocation (yyVals[-2+yyTop]), "Expected catch or finally");
 		yyVal = null;
 	  }
 
-void case_834()
-#line 5320 "cs-parser.jay"
+void case_836()
+#line 5326 "cs-parser.jay"
 {
 		var l = new List<Catch> (2);
 
@@ -7793,8 +7802,8 @@ void case_834()
 		yyVal = l;
 	  }
 
-void case_835()
-#line 5327 "cs-parser.jay"
+void case_837()
+#line 5333 "cs-parser.jay"
 {
 		var l = (List<Catch>) yyVals[-1+yyTop];
 		
@@ -7811,8 +7820,8 @@ void case_835()
 		yyVal = l;
 	  }
 
-void case_839()
-#line 5355 "cs-parser.jay"
+void case_841()
+#line 5361 "cs-parser.jay"
 {
 		start_block (GetLocation (yyVals[-3+yyTop]));
 		var c = new Catch (current_block, GetLocation (yyVals[-4+yyTop]));
@@ -7828,8 +7837,8 @@ void case_839()
 		yyVal = c;
 	  }
 
-void case_841()
-#line 5374 "cs-parser.jay"
+void case_843()
+#line 5380 "cs-parser.jay"
 {
 	  	if (yyToken == Token.CLOSE_PARENS) {
 			report.Error (1015, lexer.Location,
@@ -7841,15 +7850,15 @@ void case_841()
 		yyVal = new Catch (null, GetLocation (yyVals[-2+yyTop]));
 	  }
 
-void case_844()
-#line 5402 "cs-parser.jay"
+void case_846()
+#line 5408 "cs-parser.jay"
 {
 		if (!settings.Unsafe)
 			Error_UnsafeCodeNotAllowed (GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_846()
-#line 5412 "cs-parser.jay"
+void case_848()
+#line 5418 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7858,8 +7867,8 @@ void case_846()
 		lbag.AddStatement (yyVal, GetLocation (yyVals[-3+yyTop]), GetLocation (yyVals[-1+yyTop]));
 	  }
 
-void case_847()
-#line 5423 "cs-parser.jay"
+void case_849()
+#line 5429 "cs-parser.jay"
 {
 	    start_block (GetLocation (yyVals[-2+yyTop]));
 	    
@@ -7870,15 +7879,15 @@ void case_847()
 		current_variable = new Fixed.VariableDeclaration ((FullNamedExpression) yyVals[-1+yyTop], li);
 	  }
 
-void case_848()
-#line 5433 "cs-parser.jay"
+void case_850()
+#line 5439 "cs-parser.jay"
 {
 		yyVal = current_variable;
 		current_variable = null;
 	  }
 
-void case_849()
-#line 5438 "cs-parser.jay"
+void case_851()
+#line 5444 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7889,8 +7898,8 @@ void case_849()
 		yyVal = end_block (GetLocation (yyVals[-2+yyTop]));
 	  }
 
-void case_850()
-#line 5451 "cs-parser.jay"
+void case_852()
+#line 5457 "cs-parser.jay"
 {
 	    start_block (GetLocation (yyVals[-2+yyTop]));
 	    
@@ -7901,15 +7910,15 @@ void case_850()
 		current_variable = new Using.VariableDeclaration ((FullNamedExpression) yyVals[-1+yyTop], li);
 	  }
 
-void case_851()
-#line 5461 "cs-parser.jay"
+void case_853()
+#line 5467 "cs-parser.jay"
 {
 		yyVal = current_variable;	  
 		current_variable = null;
 	  }
 
-void case_852()
-#line 5466 "cs-parser.jay"
+void case_854()
+#line 5472 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7920,8 +7929,8 @@ void case_852()
 		yyVal = end_block (GetLocation (yyVals[-2+yyTop]));
 	  }
 
-void case_853()
-#line 5476 "cs-parser.jay"
+void case_855()
+#line 5482 "cs-parser.jay"
 {
 		if (yyVals[0+yyTop] is EmptyStatement && lexer.peek_token () == Token.OPEN_BRACE)
 			Warning_EmptyStatement (GetLocation (yyVals[0+yyTop]));
@@ -7931,15 +7940,15 @@ void case_853()
 		yyVal = u;
 	  }
 
-void case_855()
-#line 5492 "cs-parser.jay"
+void case_857()
+#line 5498 "cs-parser.jay"
 {
 		current_variable.Initializer = (Expression) yyVals[0+yyTop];
 		yyVal = current_variable;
 	  }
 
-void case_856()
-#line 5503 "cs-parser.jay"
+void case_858()
+#line 5509 "cs-parser.jay"
 {
 		lexer.query_parsing = false;
 			
@@ -7952,8 +7961,8 @@ void case_856()
 		current_block = current_block.Parent;
 	  }
 
-void case_857()
-#line 5515 "cs-parser.jay"
+void case_859()
+#line 5521 "cs-parser.jay"
 {
 		Linq.AQueryClause from = yyVals[-1+yyTop] as Linq.AQueryClause;
 			
@@ -7964,8 +7973,8 @@ void case_857()
 		current_block = current_block.Parent;
 	  }
 
-void case_858()
-#line 5526 "cs-parser.jay"
+void case_860()
+#line 5532 "cs-parser.jay"
 {
 	        lexer.query_parsing = false;
 		yyVal = yyVals[-1+yyTop];
@@ -7974,16 +7983,16 @@ void case_858()
 		current_block = current_block.Parent;
 	  }
 
-void case_859()
-#line 5533 "cs-parser.jay"
+void case_861()
+#line 5539 "cs-parser.jay"
 {
 	        yyVal = yyVals[-1+yyTop];
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
 	  }
 
-void case_860()
-#line 5542 "cs-parser.jay"
+void case_862()
+#line 5548 "cs-parser.jay"
 {
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  
@@ -7992,8 +8001,8 @@ void case_860()
 		yyVal = new Linq.QueryExpression (new Linq.QueryStartClause ((Linq.QueryBlock)current_block, (Expression)yyVals[0+yyTop], rv, GetLocation (yyVals[-3+yyTop])));
 	  }
 
-void case_861()
-#line 5550 "cs-parser.jay"
+void case_863()
+#line 5556 "cs-parser.jay"
 {
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  
@@ -8006,8 +8015,8 @@ void case_861()
 		);
 	  }
 
-void case_862()
-#line 5565 "cs-parser.jay"
+void case_864()
+#line 5571 "cs-parser.jay"
 {
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  
@@ -8016,8 +8025,8 @@ void case_862()
 		yyVal = new Linq.QueryExpression (new Linq.QueryStartClause ((Linq.QueryBlock)current_block, (Expression)yyVals[0+yyTop], rv, GetLocation (yyVals[-3+yyTop])));
 	  }
 
-void case_863()
-#line 5573 "cs-parser.jay"
+void case_865()
+#line 5579 "cs-parser.jay"
 {
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  
@@ -8030,8 +8039,8 @@ void case_863()
 		);
 	  }
 
-void case_865()
-#line 5592 "cs-parser.jay"
+void case_867()
+#line 5598 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		var sn = new Linq.RangeVariable (lt.Value, lt.Location);
@@ -8043,8 +8052,8 @@ void case_865()
 		((Linq.QueryBlock)current_block).AddRangeVariable (sn);
 	  }
 
-void case_867()
-#line 5607 "cs-parser.jay"
+void case_869()
+#line 5613 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		var sn = new Linq.RangeVariable (lt.Value, lt.Location);
@@ -8059,8 +8068,8 @@ void case_867()
 		((Linq.QueryBlock)current_block).AddRangeVariable (sn);
 	  }
 
-void case_868()
-#line 5624 "cs-parser.jay"
+void case_870()
+#line 5630 "cs-parser.jay"
 {
 	  	Linq.AQueryClause head = (Linq.AQueryClause)yyVals[-1+yyTop];
 		
@@ -8076,15 +8085,15 @@ void case_868()
 		yyVal = head;
 	  }
 
-void case_870()
-#line 5640 "cs-parser.jay"
+void case_872()
+#line 5646 "cs-parser.jay"
 {
 		Error_SyntaxError (yyToken);
 		yyVal = null;
 	  }
 
-void case_872()
-#line 5652 "cs-parser.jay"
+void case_874()
+#line 5658 "cs-parser.jay"
 {
 		yyVal = new Linq.Select ((Linq.QueryBlock)current_block, (Expression)yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]));
 
@@ -8092,8 +8101,8 @@ void case_872()
 		current_block = current_block.Parent;
 	  }
 
-void case_873()
-#line 5659 "cs-parser.jay"
+void case_875()
+#line 5665 "cs-parser.jay"
 {
 	  	if (linq_clause_blocks == null)
 	  		linq_clause_blocks = new Stack<Linq.QueryBlock> ();
@@ -8102,8 +8111,8 @@ void case_873()
 	  	linq_clause_blocks.Push ((Linq.QueryBlock)current_block);
 	  }
 
-void case_874()
-#line 5667 "cs-parser.jay"
+void case_876()
+#line 5673 "cs-parser.jay"
 {
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
@@ -8111,8 +8120,8 @@ void case_874()
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
 
-void case_875()
-#line 5674 "cs-parser.jay"
+void case_877()
+#line 5680 "cs-parser.jay"
 {
 		yyVal = new Linq.GroupBy ((Linq.QueryBlock)current_block, (Expression)yyVals[-3+yyTop], linq_clause_blocks.Pop (), (Expression)yyVals[0+yyTop], GetLocation (yyVals[-5+yyTop]));
 		lbag.AddLocation (yyVal, GetLocation (yyVals[-1+yyTop]));
@@ -8121,15 +8130,15 @@ void case_875()
 		current_block = current_block.Parent;
 	  }
 
-void case_879()
-#line 5691 "cs-parser.jay"
+void case_881()
+#line 5697 "cs-parser.jay"
 {
 		((Linq.AQueryClause)yyVals[-1+yyTop]).Tail.Next = (Linq.AQueryClause)yyVals[0+yyTop];
 		yyVal = yyVals[-1+yyTop];
 	  }
 
-void case_886()
-#line 5711 "cs-parser.jay"
+void case_888()
+#line 5717 "cs-parser.jay"
 {
 		var lt = (Tokenizer.LocatedToken) yyVals[-3+yyTop];
 		var sn = new Linq.RangeVariable (lt.Value, lt.Location);
@@ -8142,8 +8151,8 @@ void case_886()
 		((Linq.QueryBlock)current_block).AddRangeVariable (sn);
 	  }
 
-void case_888()
-#line 5730 "cs-parser.jay"
+void case_890()
+#line 5736 "cs-parser.jay"
 {
 		yyVal = new Linq.Where ((Linq.QueryBlock)current_block, (Expression)yyVals[0+yyTop], GetLocation (yyVals[-2+yyTop]));
 
@@ -8151,8 +8160,8 @@ void case_888()
 		current_block = current_block.Parent;
 	  }
 
-void case_889()
-#line 5740 "cs-parser.jay"
+void case_891()
+#line 5746 "cs-parser.jay"
 {
 		if (linq_clause_blocks == null)
 			linq_clause_blocks = new Stack<Linq.QueryBlock> ();
@@ -8161,8 +8170,8 @@ void case_889()
 		linq_clause_blocks.Push ((Linq.QueryBlock) current_block);
 	  }
 
-void case_890()
-#line 5748 "cs-parser.jay"
+void case_892()
+#line 5754 "cs-parser.jay"
 {
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
@@ -8171,8 +8180,8 @@ void case_890()
 		linq_clause_blocks.Push ((Linq.QueryBlock) current_block);
 	  }
 
-void case_891()
-#line 5756 "cs-parser.jay"
+void case_893()
+#line 5762 "cs-parser.jay"
 {
 		current_block.AddStatement (new ContextualReturn ((Expression) yyVals[-1+yyTop]));
 		current_block.SetEndLocation (lexer.Location);
@@ -8181,8 +8190,8 @@ void case_891()
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
 
-void case_892()
-#line 5764 "cs-parser.jay"
+void case_894()
+#line 5770 "cs-parser.jay"
 {
 		current_block.AddStatement (new ContextualReturn ((Expression) yyVals[-1+yyTop]));
 		current_block.SetEndLocation (lexer.Location);
@@ -8221,8 +8230,8 @@ void case_892()
 		((Linq.QueryBlock)current_block).AddRangeVariable (into);
 	  }
 
-void case_893()
-#line 5802 "cs-parser.jay"
+void case_895()
+#line 5808 "cs-parser.jay"
 {
 		if (linq_clause_blocks == null)
 			linq_clause_blocks = new Stack<Linq.QueryBlock> ();
@@ -8231,8 +8240,8 @@ void case_893()
 		linq_clause_blocks.Push ((Linq.QueryBlock) current_block);
 	  }
 
-void case_894()
-#line 5810 "cs-parser.jay"
+void case_896()
+#line 5816 "cs-parser.jay"
 {
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
@@ -8241,8 +8250,8 @@ void case_894()
 		linq_clause_blocks.Push ((Linq.QueryBlock) current_block);
 	  }
 
-void case_895()
-#line 5818 "cs-parser.jay"
+void case_897()
+#line 5824 "cs-parser.jay"
 {
 		current_block.AddStatement (new ContextualReturn ((Expression) yyVals[-1+yyTop]));
 		current_block.SetEndLocation (lexer.Location);
@@ -8251,8 +8260,8 @@ void case_895()
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
 
-void case_896()
-#line 5826 "cs-parser.jay"
+void case_898()
+#line 5832 "cs-parser.jay"
 {
 		current_block.AddStatement (new ContextualReturn ((Expression) yyVals[-1+yyTop]));
 		current_block.SetEndLocation (lexer.Location);
@@ -8293,8 +8302,8 @@ void case_896()
 		((Linq.QueryBlock)current_block).AddRangeVariable (into);		
 	  }
 
-void case_900()
-#line 5881 "cs-parser.jay"
+void case_902()
+#line 5887 "cs-parser.jay"
 {
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
@@ -8302,8 +8311,8 @@ void case_900()
 		yyVal = yyVals[0+yyTop];
 	  }
 
-void case_902()
-#line 5892 "cs-parser.jay"
+void case_904()
+#line 5898 "cs-parser.jay"
 {
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
@@ -8311,15 +8320,15 @@ void case_902()
 		current_block = new Linq.QueryBlock (current_block, lexer.Location);
 	  }
 
-void case_903()
-#line 5899 "cs-parser.jay"
+void case_905()
+#line 5905 "cs-parser.jay"
 {
 		((Linq.AQueryClause)yyVals[-3+yyTop]).Next = (Linq.AQueryClause)yyVals[0+yyTop];
 		yyVal = yyVals[-3+yyTop];
 	  }
 
-void case_905()
-#line 5908 "cs-parser.jay"
+void case_907()
+#line 5914 "cs-parser.jay"
 {
 		current_block.SetEndLocation (lexer.Location);
 		current_block = current_block.Parent;
@@ -8327,43 +8336,43 @@ void case_905()
 		current_block = new Linq.QueryBlock ((Linq.QueryBlock) current_block, lexer.Location);	 
 	 }
 
-void case_906()
-#line 5915 "cs-parser.jay"
+void case_908()
+#line 5921 "cs-parser.jay"
 {
 		((Linq.AQueryClause)yyVals[-3+yyTop]).Tail.Next = (Linq.AQueryClause)yyVals[0+yyTop];
 		yyVal = yyVals[-3+yyTop];
 	 }
 
-void case_908()
-#line 5927 "cs-parser.jay"
+void case_910()
+#line 5933 "cs-parser.jay"
 {
 		yyVal = new Linq.OrderByAscending ((Linq.QueryBlock) current_block, (Expression)yyVals[-1+yyTop]);	
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_909()
-#line 5932 "cs-parser.jay"
+void case_911()
+#line 5938 "cs-parser.jay"
 {
 		yyVal = new Linq.OrderByDescending ((Linq.QueryBlock) current_block, (Expression)yyVals[-1+yyTop]);	
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_911()
-#line 5944 "cs-parser.jay"
+void case_913()
+#line 5950 "cs-parser.jay"
 {
 		yyVal = new Linq.ThenByAscending ((Linq.QueryBlock) current_block, (Expression)yyVals[-1+yyTop]);	
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_912()
-#line 5949 "cs-parser.jay"
+void case_914()
+#line 5955 "cs-parser.jay"
 {
 		yyVal = new Linq.ThenByDescending ((Linq.QueryBlock) current_block, (Expression)yyVals[-1+yyTop]);	
 		lbag.AddLocation (yyVal, GetLocation (yyVals[0+yyTop]));
 	  }
 
-void case_914()
-#line 5959 "cs-parser.jay"
+void case_916()
+#line 5965 "cs-parser.jay"
 {
 		/* query continuation block is not linked with query block but with block*/
 		/* before. This means each query can use same range variable names for*/
@@ -8380,8 +8389,8 @@ void case_914()
 		linq_clause_blocks.Push ((Linq.QueryBlock) current_block);		
 	  }
 
-void case_915()
-#line 5975 "cs-parser.jay"
+void case_917()
+#line 5981 "cs-parser.jay"
 {
 		var current_block = linq_clause_blocks.Pop ();	  
 		var lt = (Tokenizer.LocatedToken) yyVals[-2+yyTop];
@@ -8391,8 +8400,8 @@ void case_915()
   		};
 	  }
 
-void case_918()
-#line 6002 "cs-parser.jay"
+void case_920()
+#line 6008 "cs-parser.jay"
 { 
 		current_container = new Class (current_namespace, current_class, new MemberName ("<InteractiveExpressionClass>"), Modifiers.PUBLIC, null);
 		current_class = current_container;
@@ -8423,8 +8432,8 @@ void case_918()
 		start_block (lexer.Location);
 	  }
 
-void case_919()
-#line 6032 "cs-parser.jay"
+void case_921()
+#line 6038 "cs-parser.jay"
 {
 		--lexer.parsing_block;
 		Method method = (Method) oob_stack.Pop ();
@@ -8435,16 +8444,16 @@ void case_919()
 		current_local_parameters = null;
 	  }
 
-void case_929()
-#line 6075 "cs-parser.jay"
+void case_931()
+#line 6081 "cs-parser.jay"
 {
 		module.DocumentationBuilder.ParsedBuiltinType = (TypeExpression)yyVals[-1+yyTop];
 		module.DocumentationBuilder.ParsedParameters = (List<DocumentationParameter>)yyVals[0+yyTop];
 		yyVal = null;
 	  }
 
-void case_930()
-#line 6081 "cs-parser.jay"
+void case_932()
+#line 6087 "cs-parser.jay"
 {
 		module.DocumentationBuilder.ParsedBuiltinType = (TypeExpression)yyVals[-3+yyTop];
 		module.DocumentationBuilder.ParsedParameters = (List<DocumentationParameter>)yyVals[0+yyTop];
@@ -8452,15 +8461,15 @@ void case_930()
 		yyVal = new MemberName (lt.Value);
 	  }
 
-void case_933()
-#line 6096 "cs-parser.jay"
+void case_935()
+#line 6102 "cs-parser.jay"
 {
 		module.DocumentationBuilder.ParsedParameters = (List<DocumentationParameter>)yyVals[-1+yyTop];
 		yyVal = new MemberName ((MemberName) yyVals[-6+yyTop], new MemberName (MemberCache.IndexerNameAlias));
 	  }
 
-void case_934()
-#line 6101 "cs-parser.jay"
+void case_936()
+#line 6107 "cs-parser.jay"
 {
 		var p = (List<DocumentationParameter>)yyVals[0+yyTop] ?? new List<DocumentationParameter> (1);
 		p.Add (new DocumentationParameter ((FullNamedExpression) yyVals[-1+yyTop]));
@@ -8469,8 +8478,8 @@ void case_934()
 		yyVal = null;
 	  }
 
-void case_935()
-#line 6109 "cs-parser.jay"
+void case_937()
+#line 6115 "cs-parser.jay"
 {
 		var p = (List<DocumentationParameter>)yyVals[0+yyTop] ?? new List<DocumentationParameter> (1);
 		p.Add (new DocumentationParameter ((FullNamedExpression) yyVals[-1+yyTop]));
@@ -8479,8 +8488,8 @@ void case_935()
 		yyVal = null;
 	  }
 
-void case_936()
-#line 6117 "cs-parser.jay"
+void case_938()
+#line 6123 "cs-parser.jay"
 {
 		var p = (List<DocumentationParameter>)yyVals[0+yyTop] ?? new List<DocumentationParameter> (1);
 		module.DocumentationBuilder.ParsedParameters = p;
@@ -8488,24 +8497,24 @@ void case_936()
 		yyVal = null;
 	  }
 
-void case_944()
-#line 6155 "cs-parser.jay"
+void case_946()
+#line 6161 "cs-parser.jay"
 {
 		var parameters = new List<DocumentationParameter> ();
 		parameters.Add ((DocumentationParameter) yyVals[0+yyTop]);
 		yyVal = parameters;
 	  }
 
-void case_945()
-#line 6161 "cs-parser.jay"
+void case_947()
+#line 6167 "cs-parser.jay"
 {
 		var parameters = yyVals[-2+yyTop] as List<DocumentationParameter>;
 		parameters.Add ((DocumentationParameter) yyVals[0+yyTop]);
 		yyVal = parameters;
 	  }
 
-void case_946()
-#line 6170 "cs-parser.jay"
+void case_948()
+#line 6176 "cs-parser.jay"
 {
 		if (yyVals[-1+yyTop] != null)
 			yyVal = new DocumentationParameter ((Parameter.Modifier) yyVals[-1+yyTop], (FullNamedExpression) yyVals[0+yyTop]);
@@ -8570,46 +8579,46 @@ void case_946()
    85,  266,  266,  267,  228,  268,  268,  268,  269,  269,
   269,  269,  269,  270,  196,  229,  230,  231,  232,  272,
   233,  271,  271,  274,  273,  219,  275,  275,  275,  275,
-  277,  276,  276,  276,  276,  276,  276,  276,  278,  278,
-  278,  278,  279,  279,  279,  279,  279,  279,  280,  280,
-  280,  281,  281,  281,  281,  281,  282,  282,  282,  283,
+  275,  277,  278,  276,  276,  276,  276,  276,  276,  276,
+  279,  279,  279,  279,  280,  280,  280,  280,  280,  280,
+  281,  281,  281,  282,  282,  282,  282,  282,  283,  283,
   283,  284,  284,  285,  285,  286,  286,  287,  287,  288,
-  288,  289,  289,  290,  290,  290,  290,  290,  290,  290,
-  290,  290,  290,  290,  291,  291,  292,  292,  292,  293,
-  293,  294,  294,  297,  295,  296,  296,  299,  298,  300,
-  301,  298,   46,   46,  246,  246,  246,  246,  234,  234,
-  234,   84,  303,  304,  305,  306,  307,   28,   63,   63,
-   62,   62,  111,  111,  308,  308,  308,  308,  308,  308,
-  308,  308,  308,  308,  308,  308,  308,  308,  308,   66,
-   66,   68,   68,   68,  309,  309,  310,  311,  311,  312,
-  312,  312,  312,  205,  205,  313,  313,  315,  112,  316,
-  316,  317,  160,  314,  314,  318,  318,  319,  319,  319,
-  319,  323,  323,  324,  324,  324,  321,  321,  321,  321,
-  321,  321,  321,  321,  321,  321,  321,  321,  321,  325,
-  325,  325,  325,  325,  325,  325,  325,  325,  325,  325,
-  325,  325,  339,  339,  339,  339,  326,  340,  322,  341,
-  341,  342,  342,  342,  342,  342,  342,  209,  209,  343,
-  345,  320,  348,  320,  344,  344,  344,  346,  346,  351,
-  351,  352,  352,  347,  347,  349,  349,  353,  353,  354,
-  350,  350,  350,  327,  327,  338,  338,  355,  356,  356,
-  328,  328,  357,  357,  360,  358,  359,  359,  361,  361,
-  361,  364,  362,  363,  363,  365,  365,  329,  329,  329,
-  329,  366,  367,  371,  368,  370,  370,  372,  372,  376,
-  375,  375,  373,  373,  374,  374,  378,  377,  377,  369,
-  379,  369,  330,  330,  330,  330,  330,  330,  380,  381,
-  382,  382,  382,  383,  384,  385,  385,  386,  386,  331,
-  331,  331,  331,  387,  387,  389,  389,  388,  390,  388,
-  388,  332,  333,  391,  336,  334,  393,  394,  337,  395,
-  396,  335,  335,  392,  392,  302,  302,  302,  302,  397,
-  397,  399,  399,  401,  400,  402,  400,  398,  398,  398,
-  406,  404,  407,  408,  404,  403,  403,  409,  409,  410,
-  410,  410,  410,  410,  415,  411,  416,  412,  417,  418,
-  419,  413,  421,  422,  423,  413,  420,  420,  425,  414,
-  424,  428,  424,  427,  430,  427,  426,  426,  426,  429,
-  429,  429,  405,  431,  405,    3,    3,  432,    3,    3,
-  433,  433,  247,  247,  242,  242,    5,  434,  434,  434,
-  434,  438,  434,  434,  434,  434,  435,  435,  436,  439,
-  436,  437,  437,  440,  440,  441,
+  288,  289,  289,  290,  290,  291,  291,  291,  291,  291,
+  291,  291,  291,  291,  291,  291,  292,  292,  293,  293,
+  293,  294,  294,  295,  295,  298,  296,  297,  297,  300,
+  299,  301,  302,  299,   46,   46,  246,  246,  246,  246,
+  234,  234,  234,   84,  304,  305,  306,  307,  308,   28,
+   63,   63,   62,   62,  111,  111,  309,  309,  309,  309,
+  309,  309,  309,  309,  309,  309,  309,  309,  309,  309,
+  309,   66,   66,   68,   68,   68,  310,  310,  311,  312,
+  312,  313,  313,  313,  313,  205,  205,  314,  314,  316,
+  112,  317,  317,  318,  160,  315,  315,  319,  319,  320,
+  320,  320,  320,  324,  324,  325,  325,  325,  322,  322,
+  322,  322,  322,  322,  322,  322,  322,  322,  322,  322,
+  322,  326,  326,  326,  326,  326,  326,  326,  326,  326,
+  326,  326,  326,  326,  340,  340,  340,  340,  327,  341,
+  323,  342,  342,  343,  343,  343,  343,  343,  343,  209,
+  209,  344,  346,  321,  349,  321,  345,  345,  345,  347,
+  347,  352,  352,  353,  353,  348,  348,  350,  350,  354,
+  354,  355,  351,  351,  351,  328,  328,  339,  339,  356,
+  357,  357,  329,  329,  358,  358,  361,  359,  360,  360,
+  362,  362,  362,  365,  363,  364,  364,  366,  366,  330,
+  330,  330,  330,  367,  368,  372,  369,  371,  371,  373,
+  373,  377,  376,  376,  374,  374,  375,  375,  379,  378,
+  378,  370,  380,  370,  331,  331,  331,  331,  331,  331,
+  381,  382,  383,  383,  383,  384,  385,  386,  386,  387,
+  387,  332,  332,  332,  332,  388,  388,  390,  390,  389,
+  391,  389,  389,  333,  334,  392,  337,  335,  394,  395,
+  338,  396,  397,  336,  336,  393,  393,  303,  303,  303,
+  303,  398,  398,  400,  400,  402,  401,  403,  401,  399,
+  399,  399,  407,  405,  408,  409,  405,  404,  404,  410,
+  410,  411,  411,  411,  411,  411,  416,  412,  417,  413,
+  418,  419,  420,  414,  422,  423,  424,  414,  421,  421,
+  426,  415,  425,  429,  425,  428,  431,  428,  427,  427,
+  427,  430,  430,  430,  406,  432,  406,    3,    3,  433,
+    3,    3,  434,  434,  247,  247,  242,  242,    5,  435,
+  435,  435,  435,  439,  435,  435,  435,  435,  436,  436,
+  437,  440,  437,  438,  438,  441,  441,  442,
   };
    static readonly short [] yyLen = {           2,
     2,    0,    3,    1,    2,    4,    3,    1,    0,    1,
@@ -8667,2587 +8676,2620 @@ void case_946()
     4,    1,    3,    0,    5,    1,    1,    1,    2,    3,
     3,    4,    4,    1,    2,    4,    4,    4,    4,    0,
     4,    0,    1,    0,    4,    4,    1,    2,    2,    1,
-    4,    1,    2,    2,    2,    2,    2,    2,    1,    3,
-    3,    3,    1,    3,    3,    3,    3,    3,    1,    3,
-    3,    1,    3,    3,    3,    3,    1,    3,    3,    1,
+    1,    4,    2,    1,    2,    2,    2,    2,    2,    2,
+    1,    3,    3,    3,    1,    3,    3,    3,    3,    3,
+    1,    3,    3,    1,    3,    3,    3,    3,    1,    3,
     3,    1,    3,    1,    3,    1,    3,    1,    3,    1,
-    3,    1,    5,    3,    3,    3,    3,    3,    3,    3,
-    3,    3,    3,    3,    1,    3,    3,    2,    1,    0,
-    1,    1,    1,    0,    2,    1,    1,    0,    4,    0,
-    0,    7,    1,    1,    1,    1,    1,    1,    6,    4,
-    4,    1,    1,    0,    0,    0,    0,   15,    0,    1,
-    0,    1,    1,    2,    1,    1,    1,    1,    1,    1,
-    1,    1,    1,    1,    1,    1,    1,    1,    1,    0,
-    2,    0,    1,    1,    1,    2,    4,    1,    3,    1,
-    3,    1,    1,    0,    1,    1,    1,    0,    4,    1,
-    1,    0,    4,    0,    1,    1,    2,    1,    1,    1,
-    1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
+    3,    1,    3,    1,    5,    3,    3,    3,    3,    3,
+    3,    3,    3,    3,    3,    3,    1,    3,    3,    2,
+    1,    0,    1,    1,    1,    0,    2,    1,    1,    0,
+    4,    0,    0,    7,    1,    1,    1,    1,    1,    1,
+    6,    4,    4,    1,    1,    0,    0,    0,    0,   15,
+    0,    1,    0,    1,    1,    2,    1,    1,    1,    1,
     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+    1,    0,    2,    0,    1,    1,    1,    2,    4,    1,
+    3,    1,    3,    1,    1,    0,    1,    1,    1,    0,
+    4,    1,    1,    0,    4,    0,    1,    1,    2,    1,
+    1,    1,    1,    1,    2,    1,    1,    1,    1,    1,
     1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-    1,    1,    1,    1,    1,    1,    1,    0,    4,    1,
-    2,    2,    2,    2,    2,    2,    1,    1,    2,    1,
-    0,    6,    0,    7,    0,    2,    1,    0,    1,    1,
-    2,    2,    4,    0,    2,    0,    1,    1,    2,    4,
-    1,    5,    2,    2,    2,    2,    2,    1,    1,    1,
-    1,    1,    5,    7,    0,    8,    0,    1,    1,    2,
-    1,    0,    3,    1,    2,    3,    1,    1,    1,    1,
-    1,    5,    7,    0,    4,    7,    1,    0,    1,    0,
-    5,    1,    0,    1,    0,    1,    1,    1,    3,    6,
-    0,    9,    1,    1,    1,    1,    1,    1,    2,    2,
-    3,    4,    3,    3,    3,    4,    3,    0,    1,    3,
-    4,    5,    3,    1,    2,    0,    1,    2,    0,    7,
-    3,    2,    2,    0,    3,    5,    0,    0,   10,    0,
-    0,   10,    5,    0,    2,    2,    2,    2,    2,    4,
-    5,    4,    5,    0,    5,    0,    6,    3,    2,    1,
-    0,    3,    0,    0,    6,    0,    1,    1,    2,    1,
-    1,    1,    1,    1,    0,    5,    0,    3,    0,    0,
-    0,   12,    0,    0,    0,   13,    0,    2,    0,    3,
-    1,    0,    4,    1,    0,    4,    1,    2,    2,    1,
-    2,    2,    0,    0,    4,    2,    3,    0,    4,    2,
-    2,    3,    0,    1,    1,    1,    2,    2,    2,    4,
-    3,    0,    7,    4,    4,    3,    1,    3,    0,    0,
-    4,    0,    1,    1,    3,    2,
+    1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+    1,    1,    1,    1,    1,    1,    1,    1,    1,    0,
+    4,    1,    2,    2,    2,    2,    2,    2,    1,    1,
+    2,    1,    0,    6,    0,    7,    0,    2,    1,    0,
+    1,    1,    2,    2,    4,    0,    2,    0,    1,    1,
+    2,    4,    1,    5,    2,    2,    2,    2,    2,    1,
+    1,    1,    1,    1,    5,    7,    0,    8,    0,    1,
+    1,    2,    1,    0,    3,    1,    2,    3,    1,    1,
+    1,    1,    1,    5,    7,    0,    4,    7,    1,    0,
+    1,    0,    5,    1,    0,    1,    0,    1,    1,    1,
+    3,    6,    0,    9,    1,    1,    1,    1,    1,    1,
+    2,    2,    3,    4,    3,    3,    3,    4,    3,    0,
+    1,    3,    4,    5,    3,    1,    2,    0,    1,    2,
+    0,    7,    3,    2,    2,    0,    3,    5,    0,    0,
+   10,    0,    0,   10,    5,    0,    2,    2,    2,    2,
+    2,    4,    5,    4,    5,    0,    5,    0,    6,    3,
+    2,    1,    0,    3,    0,    0,    6,    0,    1,    1,
+    2,    1,    1,    1,    1,    1,    0,    5,    0,    3,
+    0,    0,    0,   12,    0,    0,    0,   13,    0,    2,
+    0,    3,    1,    0,    4,    1,    0,    4,    1,    2,
+    2,    1,    2,    2,    0,    0,    4,    2,    3,    0,
+    4,    2,    2,    3,    0,    1,    1,    1,    2,    2,
+    2,    4,    3,    0,    7,    4,    4,    3,    1,    3,
+    0,    0,    4,    0,    1,    1,    3,    2,
   };
    static readonly short [] yyDefRed = {            0,
     8,    0,    0,    0,    0,    0,    0,    0,    2,    4,
-    0,    0,   11,   14,    0,  916,    0,    0,  920,    0,
+    0,    0,   11,   14,    0,  918,    0,    0,  922,    0,
     0,   15,   17,   18,  388,  394,  401,  389,  391,    0,
   390,    0,  397,  399,  386,    0,  393,  395,  387,  398,
-  400,  396,  350,  937,    0,  392,  927,    0,   10,    1,
-    0,    0,    0,   12,    0,  770,    0,    0,    0,    0,
+  400,  396,  350,  939,    0,  392,  929,    0,   10,    1,
+    0,    0,    0,   12,    0,  772,    0,    0,    0,    0,
     0,    0,    0,    0,  429,    0,    0,    0,    0,    0,
     0,    0,  427,    0,    0,    0,  485,    0,  428,    0,
-  524,    0,  844,    0,    0,    0,  628,    0,    0,    0,
-    0,    0,  678,    0,  727,    0,    0,    0,    0,    0,
-    0,    0,    0,  426,    0,  620,    0,  769,  710,    0,
-    0,    0,    0,  403,  404,    0,  406,  407,  408,  409,
-  410,  411,  412,  413,  414,  415,  416,  417,  418,  419,
-  420,  421,  424,  425,  624,  552,    0,  550,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  625,
-  623,  626,  627,  694,  696,    0,  692,  695,  711,  713,
-  714,  715,  716,  717,  718,  719,  720,  721,  722,  712,
-    0,    0,    0,  771,  772,  788,  789,  790,  791,  813,
-  814,  815,  816,  817,  818,    0,    0,    0,   20,    0,
-    0,    0,  340,    0,  342,  924,   16,  917,    0,    0,
-  253,  252,  249,  254,  255,  248,  267,  266,  259,  260,
-  256,  258,  257,  261,  250,  251,  262,  263,  269,  268,
-  264,  265,    0,    0,  940,    0,  929,    0,  928,    3,
-   52,    0,    0,    0,   42,   39,   41,   43,   44,   45,
-   46,   47,   50,   13,    0,    0,    0,  819,  430,  431,
-  842,    0,    0,    0,    0,    0,  405,    0,  820,    0,
-  544,  540,  543,  726,  768,  697,  724,  723,  725,  698,
-  699,  700,  701,  702,  703,  704,  705,  706,  707,  708,
-  709,    0,    0,    0,  794,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  829,    0,  402,
-    0,    0,    0,    0,    0,    0,  843,    0,    0,    0,
-  740,  736,    0,    0,    0,    0,    0,    0,  369,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  549,  553,
-  554,  548,  558,  557,  555,  556,    0,    0,  618,  728,
-  535,    0,  423,  422,    0,    0,    0,    0,  339,    0,
-  734,  735,    0,  488,  489,    0,    0,    0,  732,  733,
+  524,    0,  846,    0,    0,    0,  630,    0,    0,    0,
+    0,    0,    0,  680,    0,  729,    0,    0,    0,    0,
+    0,    0,    0,    0,  426,    0,  622,    0,  771,  712,
+    0,    0,    0,    0,  403,  404,    0,  406,  407,  408,
+  409,  410,  411,  412,  413,  414,  415,  416,  417,  418,
+  419,  420,  421,  424,  425,  626,  554,    0,  550,  551,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,  627,  625,  628,  629,  696,  698,    0,  694,  697,
+  713,  715,  716,  717,  718,  719,  720,  721,  722,  723,
+  724,  714,    0,    0,    0,  773,  774,  790,  791,  792,
+  793,  815,  816,  817,  818,  819,  820,    0,    0,    0,
+   20,    0,    0,    0,  340,    0,  342,  926,   16,  919,
+    0,    0,  253,  252,  249,  254,  255,  248,  267,  266,
+  259,  260,  256,  258,  257,  261,  250,  251,  262,  263,
+  269,  268,  264,  265,    0,    0,  942,    0,  931,    0,
+  930,    3,   52,    0,    0,    0,   42,   39,   41,   43,
+   44,   45,   46,   47,   50,   13,    0,    0,    0,  821,
+  430,  431,  844,    0,    0,    0,    0,    0,  405,    0,
+  822,    0,  544,  540,  543,  728,  770,  699,  726,  725,
+  727,  700,  701,  702,  703,  704,  705,  706,  707,  708,
+  709,  710,  711,    0,    0,    0,  796,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,  831,
+    0,  402,    0,    0,    0,    0,    0,    0,  845,    0,
+    0,    0,  742,  738,    0,    0,    0,    0,    0,    0,
+  369,    0,    0,    0,    0,    0,    0,    0,  553,    0,
+    0,  549,  555,  556,  548,  560,  559,  557,  558,    0,
+    0,  620,  730,  535,    0,  423,  422,    0,    0,    0,
+    0,  339,    0,  736,  737,    0,  488,  489,    0,    0,
+    0,  734,  735,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  919,  693,  741,  731,    0,  766,
-  767,  870,  887,    0,    0,    0,  899,  858,  856,  880,
-    0,    0,  878,  881,  882,  883,  884,  859,  857,    0,
-    0,    0,  344,    0,   21,    0,    0,    0,  936,    0,
-  351,    0,    0,    0,  938,    0,    0,   40,  650,  656,
-  648,    0,  645,  655,  649,  647,  646,  653,  651,  652,
-  658,  654,  657,  659,    0,    0,  643,   51,  487,    0,
-    0,  483,  484,    0,  481,    0,  743,    0,    0,    0,
-    0,  764,  765,    0,    0,    0,  632,    0,  823,  821,
-  633,    0,    0,  509,    0,    0,    0,  500,    0,  504,
-  514,  516,    0,  496,    0,    0,    0,    0,    0,  491,
-    0,  494,    0,  498,  371,  824,    0,    0,  825,  833,
-    0,    0,    0,  834,    0,    0,  845,    0,    0,  739,
-    0,  381,    0,  377,  378,    0,  376,  379,  380,    0,
-    0,    0,  559,    0,    0,  691,    0,    0,  686,  688,
-  689,  690,  434,  435,  827,    0,    0,    0,  347,  348,
-    0,  191,  190,  192,    0,    0,    0,    0,  373,    0,
-  605,    0,    0,  439,    0,  442,    0,  440,    0,    0,
-    0,    0,    0,    0,  468,  471,    0,    0,  463,  470,
-  469,    0,  594,  595,  596,  597,  598,  599,  600,  601,
-  602,  604,  603,  560,  562,  561,  567,  568,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  591,    0,    0,  513,    0,    0,    0,
-    0,    0,    0,    0,  871,  873,  869,    0,  879,    0,
-    0,  341,  934,  935,  365,    0,    0,  362,    0,    0,
-  188,    0,    0,  944,  930,  932,   60,   58,   59,    0,
-    0,   53,    0,    0,   61,   63,   27,   25,    0,    0,
-    0,  640,    0,  644,  438,    0,  486,    0,  537,    0,
-  546,  178,  199,    0,    0,  168,    0,    0,    0,  179,
-  541,    0,  847,  797,    0,  808,  795,    0,  799,    0,
-    0,    0,  822,    0,    0,    0,  499,    0,  515,  517,
-    0,    0,  455,    0,    0,  451,    0,    0,  478,    0,
-  519,  493,    0,  155,  520,  153,  154,  522,    0,  536,
-    0,  838,    0,  831,    0,  835,  528,    0,    0,    0,
-  366,    0,  526,    0,    0,  538,    0,  850,    0,  862,
-    0,  860,    0,    0,  630,  631,  680,  681,  679,  687,
-  826,  613,  619,  612,    0,  729,    0,  346,  608,    0,
-    0,    0,  551,  443,  437,  441,  436,  539,  477,  476,
-  473,  472,    0,  467,  432,  433,  444,    0,    0,  747,
-    0,    0,  888,  864,    0,  889,    0,  885,    0,  900,
-    0,    0,    0,    0,  868,   19,  343,  677,  676,    0,
-  675,    0,  361,  946,  189,  941,    0,    0,   54,    0,
-    0,    0,    0,    0,    0,  368,    0,  634,    0,    0,
-   80,   79,    0,  482,    0,    0,    0,    0,    0,  545,
-    0,    0,    0,    0,    0,  800,    0,    0,    0,    0,
-    0,  846,  506,  505,  458,    0,    0,  925,  926,  447,
-  453,    0,  456,    0,  480,    0,    0,    0,    0,    0,
-  775,  841,    0,  832,  534,  529,    0,    0,  525,    0,
-  853,    0,  792,  863,  861,    0,  617,  616,  615,  349,
-  607,  606,  621,  475,    0,  465,  464,  593,    0,  761,
-  746,    0,    0,    0,  750,    0,  866,    0,  893,    0,
-  908,  909,  902,  872,  874,  914,  364,  363,  945,    0,
-    0,   62,   56,    0,   64,   26,   23,    0,    0,  319,
-    0,  225,    0,  101,    0,   77,  755,  128,  129,    0,
-    0,    0,  758,  197,  198,    0,    0,    0,    0,  171,
-  180,  172,  174,    0,    0,    0,    0,  804,    0,  809,
-  810,    0,    0,  457,  459,  460,  454,  448,  452,    0,
-  511,    0,  479,  490,  446,  523,  521,    0,  837,    0,
-    0,  530,    0,    0,  629,    0,  474,    0,    0,  742,
-  751,  865,    0,    0,    0,  886,    0,    0,    0,  933,
-    0,    0,    0,   69,   70,   73,   74,    0,  334,  325,
-  324,    0,  635,  221,   97,    0,  744,  759,  183,    0,
-  195,    0,    0,    0,  793,  855,    0,    0,    0,  811,
-  774,  495,  492,  781,    0,  787,    0,    0,  779,    0,
-  784,  839,  533,  532,    0,  622,    0,    0,  867,  890,
-    0,    0,    0,  904,    0,  915,    0,   75,   67,    0,
-    0,    0,  320,    0,    0,    0,    0,    0,  184,    0,
-  175,  173,  848,  801,    0,    0,  806,    0,    0,  776,
-  780,    0,  785,    0,  851,    0,  753,    0,  894,  911,
-  912,  905,  875,   55,    0,   71,   72,    0,    0,    0,
-    0,    0,    0,    0,  760,  182,    0,  194,    0,    0,
-  812,  786,    0,  682,  840,    0,  762,    0,    0,    0,
-   76,    0,    0,  335,    0,  321,    0,  329,  385,  384,
-    0,  382,  664,    0,  636,    0,  665,  222,   98,  185,
-  849,  796,    0,  852,  891,    0,  906,    0,    0,    0,
-    0,    0,    0,    0,    0,  666,    0,    0,    0,    0,
-  895,   29,   24,  336,    0,    0,  330,  383,    0,    0,
-    0,  102,   99,  683,    0,    0,    0,    0,  322,  672,
-    0,  673,  670,    0,  668,   95,    0,   94,    0,    0,
-   83,   85,   86,   87,   88,   89,   90,   91,   92,   93,
-  156,    0,    0,  238,  230,  231,  232,  233,  234,  235,
-  236,  237,    0,    0,  228,    0,    0,    0,  892,    0,
-  337,  333,    0,    0,    0,  637,   84,    0,  281,  276,
-  280,    0,  223,  229,  116,  108,  109,  110,  111,  112,
-  113,  114,  115,  117,    0,    0,  106,  100,  898,  896,
-  671,  669,    0,    0,    0,    0,    0,    0,    0,  289,
-    0,    0,  239,    0,    0,  247,    0,  166,  157,  165,
-    0,  103,  107,    0,    0,  275,    0,    0,  274,    0,
-    0,    0,    0,  355,    0,  353,    0,    0,  200,    0,
-    0,    0,    0,    0,  638,  224,  118,    0,  352,    0,
-    0,    0,    0,  132,    0,    0,    0,    0,    0,    0,
-  158,    0,    0,  204,    0,  356,    0,  242,  241,  240,
-    0,    0,  293,    0,  272,  134,    0,  270,  161,    0,
-    0,  136,    0,  357,    0,    0,  201,    0,    0,    0,
-  354,  245,  127,  125,    0,    0,  297,    0,    0,    0,
-    0,    0,    0,    0,  278,    0,    0,    0,    0,  140,
-    0,    0,    0,    0,  358,  359,    0,    0,    0,    0,
-    0,  122,  312,    0,  294,    0,    0,  306,    0,    0,
-    0,  301,    0,  152,    0,    0,    0,    0,  147,    0,
-    0,  290,    0,  137,    0,  131,  141,  159,  164,  212,
-    0,  202,    0,    0,    0,    0,  126,    0,  119,  123,
-    0,    0,    0,  308,    0,  309,  298,    0,    0,  292,
-  302,  273,    0,    0,  133,  148,  271,  162,  288,    0,
-  279,  283,  143,    0,    0,    0,  209,  211,  205,  246,
-  124,  313,  315,  295,    0,    0,  307,  304,  151,  149,
-    0,    0,    0,    0,  160,  213,  215,  203,    0,    0,
-    0,  306,  163,  284,  286,  144,    0,    0,  206,  317,
-  318,  314,  316,  305,    0,    0,  219,  218,  217,  214,
-  216,    0,    0,    0,  207,  285,  287,
+    0,    0,    0,    0,    0,    0,    0,  921,  695,  743,
+  733,    0,  768,  769,  872,  889,    0,    0,    0,  901,
+  860,  858,  882,    0,    0,  880,  883,  884,  885,  886,
+  861,  859,    0,    0,    0,  344,    0,   21,    0,    0,
+    0,  938,    0,  351,    0,    0,    0,  940,    0,    0,
+   40,  652,  658,  650,    0,  647,  657,  651,  649,  648,
+  655,  653,  654,  660,  656,  659,  661,    0,    0,  645,
+   51,  487,    0,    0,  483,  484,    0,  481,    0,  745,
+    0,    0,    0,    0,  766,  767,    0,    0,    0,  634,
+    0,  825,  823,  635,    0,    0,  509,    0,    0,    0,
+  500,    0,  504,  514,  516,    0,  496,    0,    0,    0,
+    0,    0,  491,    0,  494,    0,  498,  371,  826,    0,
+    0,  827,  835,    0,    0,    0,  836,    0,    0,  847,
+    0,    0,  741,    0,  381,    0,  377,  378,    0,  376,
+  379,  380,    0,    0,    0,  561,    0,    0,  693,    0,
+    0,  688,  690,  691,  692,  434,  435,  829,    0,    0,
+    0,  347,  348,    0,  191,  190,  192,    0,    0,    0,
+    0,  373,    0,  607,    0,    0,  439,    0,  442,    0,
+  440,    0,    0,    0,    0,    0,    0,  468,  471,    0,
+    0,  463,  470,  469,    0,  596,  597,  598,  599,  600,
+  601,  602,  603,  604,  606,  605,  562,  564,  563,  569,
+  570,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  593,    0,    0,  513,
+    0,    0,    0,    0,    0,    0,    0,  873,  875,  871,
+    0,  881,    0,    0,  341,  936,  937,  365,    0,    0,
+  362,    0,    0,  188,    0,    0,  946,  932,  934,   60,
+   58,   59,    0,    0,   53,    0,    0,   61,   63,   27,
+   25,    0,    0,    0,  642,    0,  646,  438,    0,  486,
+    0,  537,    0,  546,  178,  199,    0,    0,  168,    0,
+    0,    0,  179,  541,    0,  849,  799,    0,  810,  797,
+    0,  801,    0,    0,    0,  824,    0,    0,    0,  499,
+    0,  515,  517,    0,    0,  455,    0,    0,  451,    0,
+    0,  478,    0,  519,  493,    0,  155,  520,  153,  154,
+  522,    0,  536,    0,  840,    0,  833,    0,  837,  528,
+    0,    0,    0,  366,    0,  526,    0,    0,  538,    0,
+  852,    0,  864,    0,  862,    0,    0,  632,  633,  682,
+  683,  681,  689,  828,  615,  621,  614,    0,  731,    0,
+  346,  610,    0,    0,    0,  552,  443,  437,  441,  436,
+  539,  477,  476,  473,  472,    0,  467,  432,  433,  444,
+    0,    0,  749,    0,    0,  890,  866,    0,  891,    0,
+  887,    0,  902,    0,    0,    0,    0,  870,   19,  343,
+  679,  678,    0,  677,    0,  361,  948,  189,  943,    0,
+    0,   54,    0,    0,    0,    0,    0,    0,  368,    0,
+  636,    0,    0,   80,   79,    0,  482,    0,    0,    0,
+    0,    0,  545,    0,    0,    0,    0,    0,  802,    0,
+    0,    0,    0,    0,  848,  506,  505,  458,    0,    0,
+  927,  928,  447,  453,    0,  456,    0,  480,    0,    0,
+    0,    0,    0,  777,  843,    0,  834,  534,  529,    0,
+    0,  525,    0,  855,    0,  794,  865,  863,    0,  619,
+  618,  617,  349,  609,  608,  623,  475,    0,  465,  464,
+  595,    0,  763,  748,    0,    0,    0,  752,    0,  868,
+    0,  895,    0,  910,  911,  904,  874,  876,  916,  364,
+  363,  947,    0,    0,   62,   56,    0,   64,   26,   23,
+    0,    0,  319,    0,  225,    0,  101,    0,   77,  757,
+  128,  129,    0,    0,    0,  760,  197,  198,    0,    0,
+    0,    0,  171,  180,  172,  174,    0,    0,    0,    0,
+  806,    0,  811,  812,    0,    0,  457,  459,  460,  454,
+  448,  452,    0,  511,    0,  479,  490,  446,  523,  521,
+    0,  839,    0,    0,  530,    0,    0,  631,    0,  474,
+    0,    0,  744,  753,  867,    0,    0,    0,  888,    0,
+    0,    0,  935,    0,    0,    0,   69,   70,   73,   74,
+    0,  334,  325,  324,    0,  637,  221,   97,    0,  746,
+  761,  183,    0,  195,    0,    0,    0,  795,  857,    0,
+    0,    0,  813,  776,  495,  492,  783,    0,  789,    0,
+    0,  781,    0,  786,  841,  533,  532,    0,  624,    0,
+    0,  869,  892,    0,    0,    0,  906,    0,  917,    0,
+   75,   67,    0,    0,    0,  320,    0,    0,    0,    0,
+    0,  184,    0,  175,  173,  850,  803,    0,    0,  808,
+    0,    0,  778,  782,    0,  787,    0,  853,    0,  755,
+    0,  896,  913,  914,  907,  877,   55,    0,   71,   72,
+    0,    0,    0,    0,    0,    0,    0,  762,  182,    0,
+  194,    0,    0,  814,  788,    0,  684,  842,    0,  764,
+    0,    0,    0,   76,    0,    0,  335,    0,  321,    0,
+  329,  385,  384,    0,  382,  666,    0,  638,    0,  667,
+  222,   98,  185,  851,  798,    0,  854,  893,    0,  908,
+    0,    0,    0,    0,    0,    0,    0,    0,  668,    0,
+    0,    0,    0,  897,   29,   24,  336,    0,    0,  330,
+  383,    0,    0,    0,  102,   99,  685,    0,    0,    0,
+    0,  322,  674,    0,  675,  672,    0,  670,   95,    0,
+   94,    0,    0,   83,   85,   86,   87,   88,   89,   90,
+   91,   92,   93,  156,    0,    0,  238,  230,  231,  232,
+  233,  234,  235,  236,  237,    0,    0,  228,    0,    0,
+    0,  894,    0,  337,  333,    0,    0,    0,  639,   84,
+    0,  281,  276,  280,    0,  223,  229,  116,  108,  109,
+  110,  111,  112,  113,  114,  115,  117,    0,    0,  106,
+  100,  900,  898,  673,  671,    0,    0,    0,    0,    0,
+    0,    0,  289,    0,    0,  239,    0,    0,  247,    0,
+  166,  157,  165,    0,  103,  107,    0,    0,  275,    0,
+    0,  274,    0,    0,    0,    0,  355,    0,  353,    0,
+    0,  200,    0,    0,    0,    0,    0,  640,  224,  118,
+    0,  352,    0,    0,    0,    0,  132,    0,    0,    0,
+    0,    0,    0,  158,    0,    0,  204,    0,  356,    0,
+  242,  241,  240,    0,    0,  293,    0,  272,  134,    0,
+  270,  161,    0,    0,  136,    0,  357,    0,    0,  201,
+    0,    0,    0,  354,  245,  127,  125,    0,    0,  297,
+    0,    0,    0,    0,    0,    0,    0,  278,    0,    0,
+    0,    0,  140,    0,    0,    0,    0,  358,  359,    0,
+    0,    0,    0,    0,  122,  312,    0,  294,    0,    0,
+  306,    0,    0,    0,  301,    0,  152,    0,    0,    0,
+    0,  147,    0,    0,  290,    0,  137,    0,  131,  141,
+  159,  164,  212,    0,  202,    0,    0,    0,    0,  126,
+    0,  119,  123,    0,    0,    0,  308,    0,  309,  298,
+    0,    0,  292,  302,  273,    0,    0,  133,  148,  271,
+  162,  288,    0,  279,  283,  143,    0,    0,    0,  209,
+  211,  205,  246,  124,  313,  315,  295,    0,    0,  307,
+  304,  151,  149,    0,    0,    0,    0,  160,  213,  215,
+  203,    0,    0,    0,  306,  163,  284,  286,  144,    0,
+    0,  206,  317,  318,  314,  316,  305,    0,    0,  219,
+  218,  217,  214,  216,    0,    0,    0,  207,  285,  287,
   };
   protected static readonly short [] yyDgoto  = {             7,
-    8,   50,    9,   51,   10,   11,   52,  232,  674,  421,
-   12,   13,   53,   22,   23,   24,  317,  192,  235,  659,
-  814,  998, 1113, 1460,  811,  236,  237,  238,  239,  240,
-  241,  242,  243,  652,  436,  653,  654,  911,  655,  656,
-  915,  812,  993,  994,  995,  265,  576, 1085,  823, 1179,
- 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189,
- 1190,  455,  663, 1276,  925, 1092, 1056, 1125, 1163, 1148,
- 1207, 1235, 1206, 1236, 1237, 1120, 1335, 1312, 1360, 1361,
- 1362,  927, 1358,  928,  717, 1252, 1323, 1299, 1348,  504,
- 1341, 1317, 1377,  890, 1346, 1349, 1350, 1444, 1378, 1379,
- 1375, 1191, 1259, 1218, 1277,  675, 1325, 1424, 1343, 1441,
-  456,  266,  676,  677,  678,  679,  680,  639,  557, 1097,
-  640,  641,  829, 1279, 1303, 1392, 1353, 1426, 1280, 1328,
- 1449, 1472, 1393, 1394, 1470, 1457, 1458,  923, 1055, 1147,
- 1203, 1261, 1204, 1205, 1253, 1310, 1283, 1254,  319,  223,
- 1357, 1256, 1342, 1339, 1192, 1220, 1273, 1421, 1383, 1105,
- 1422,  577, 1465, 1466, 1272, 1338, 1314, 1370, 1365, 1336,
- 1402, 1407, 1368, 1371, 1372, 1452, 1408, 1366, 1367, 1462,
- 1450, 1451,  920, 1002, 1116, 1090, 1141, 1117, 1118, 1155,
- 1052, 1139, 1167,  524,  193,  110,  423,  195,  551,  431,
-  224, 1291,  637,  638,  800,  816,  320,  398,  522,  299,
- 1121, 1122,   46,  112,  300,  114,  115,  116,  117,  118,
-  119,  120,  121,  122,  123,  124,  125,  126,  127,  128,
-  129,  130,  131,  132,  133,  134,  252,  777,  964,  500,
-  704,  850,  705,  706,  957,  135,  198,  710,  578,  579,
-  580,  581,  771,  464,  465,  294,  962,  712,  399,  296,
-  487,  488,  489,  490,  493,  719,  306,  734,  735,  866,
-  262,  470,  263,  469,  136,  137,  138,  139,  140,  141,
-  142,  143,  144,  145,  146,  147,  148,  149,  150,  151,
-  560,  561,  562,  753,  754,  879,  755,  152,  547,  345,
-  976,  153,  482,  921, 1054, 1145, 1257,  457, 1126, 1127,
- 1174, 1175,  801,  537,  327,  749, 1133,  538,  539,  267,
-  268,  269,  156,  157,  158,  270,  271,  272,  273,  274,
-  275,  276,  277,  278,  279,  280,  281,  170,  282,  548,
-  171,  172,  313,  782,  616,  893,  826,  670,  931,  891,
-  894,  895,  932,  933,  283,  173,  174,  175, 1027,  968,
- 1028, 1029, 1030, 1072, 1031,  176,  177,  178,  179,  687,
-  475,  688,  949, 1065,  689,  947,  690, 1067, 1068,  180,
-  181,  182,  183,  184,  185,  301,  513,  514,  970, 1074,
-  309,  946,  835, 1099,  872, 1106,  186,  409,  187,  410,
-  896,  983,  411,  628,  795,  792,  793,  988,  412,  413,
-  414,  415,  416,  417,  900,  618,  898, 1078, 1150, 1209,
-  985, 1109, 1166,  790,  624,  791, 1043,  987, 1044, 1110,
-  989,   17,   19,   47,   48,  227,  642,  808,  432,  643,
-  644,
+    8,   50,    9,   51,   10,   11,   52,  234,  677,  424,
+   12,   13,   53,   22,   23,   24,  319,  194,  237,  662,
+  817, 1001, 1116, 1463,  814,  238,  239,  240,  241,  242,
+  243,  244,  245,  655,  439,  656,  657,  914,  658,  659,
+  918,  815,  996,  997,  998,  267,  579, 1088,  826, 1182,
+ 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192,
+ 1193,  458,  666, 1279,  928, 1095, 1059, 1128, 1166, 1151,
+ 1210, 1238, 1209, 1239, 1240, 1123, 1338, 1315, 1363, 1364,
+ 1365,  930, 1361,  931,  720, 1255, 1326, 1302, 1351,  507,
+ 1344, 1320, 1380,  893, 1349, 1352, 1353, 1447, 1381, 1382,
+ 1378, 1194, 1262, 1221, 1280,  678, 1328, 1427, 1346, 1444,
+  459,  268,  679,  680,  681,  682,  683,  642,  560, 1100,
+  643,  644,  832, 1282, 1306, 1395, 1356, 1429, 1283, 1331,
+ 1452, 1475, 1396, 1397, 1473, 1460, 1461,  926, 1058, 1150,
+ 1206, 1264, 1207, 1208, 1256, 1313, 1286, 1257,  321,  225,
+ 1360, 1259, 1345, 1342, 1195, 1223, 1276, 1424, 1386, 1108,
+ 1425,  580, 1468, 1469, 1275, 1341, 1317, 1373, 1368, 1339,
+ 1405, 1410, 1371, 1374, 1375, 1455, 1411, 1369, 1370, 1465,
+ 1453, 1454,  923, 1005, 1119, 1093, 1144, 1120, 1121, 1158,
+ 1055, 1142, 1170,  527,  195,  111,  426,  197,  554,  434,
+  226, 1294,  640,  641,  803,  819,  322,  401,  525,  301,
+ 1124, 1125,   46,  113,  302,  115,  116,  117,  118,  119,
+  120,  121,  122,  123,  124,  125,  126,  127,  128,  129,
+  130,  131,  132,  133,  134,  135,  254,  780,  967,  503,
+  707,  853,  708,  709,  960,  136,  200,  713,  581,  582,
+  583,  584,  774,  467,  468,  296,  965,  715,  402,  298,
+  490,  491,  492,  493,  496,  722,  308,  737,  738,  869,
+  264,  473,  265,  472,  137,  138,  139,  140,  141,  142,
+  143,  144,  145,  146,  147,  148,  149,  150,  151,  152,
+  153,  563,  564,  565,  756,  757,  882,  758,  154,  550,
+  348,  979,  155,  485,  924, 1057, 1148, 1260,  460, 1129,
+ 1130, 1177, 1178,  804,  540,  330,  752, 1136,  541,  542,
+  269,  270,  271,  158,  159,  160,  272,  273,  274,  275,
+  276,  277,  278,  279,  280,  281,  282,  283,  172,  284,
+  551,  173,  174,  315,  785,  619,  896,  829,  673,  934,
+  894,  897,  898,  935,  936,  285,  175,  176,  177, 1030,
+  971, 1031, 1032, 1033, 1075, 1034,  178,  179,  180,  181,
+  690,  478,  691,  952, 1068,  692,  950,  693, 1070, 1071,
+  182,  183,  184,  185,  186,  187,  303,  516,  517,  973,
+ 1077,  311,  949,  838, 1102,  875, 1109,  188,  412,  189,
+  413,  899,  986,  414,  631,  798,  795,  796,  991,  415,
+  416,  417,  418,  419,  420,  903,  621,  901, 1081, 1153,
+ 1212,  988, 1112, 1169,  793,  627,  794, 1046,  990, 1047,
+ 1113,  992,   17,   19,   47,   48,  229,  645,  811,  435,
+  646,  647,
   };
-  protected static readonly short [] yySindex = {         -159,
-    0, -192, -124, -184,   -8,11425,    0,  185,    0,    0,
-   -8, -184,    0,    0,   45,    0, 6321,   -8,    0, -186,
- -241,    0,    0,    0,    0,    0,    0,    0,    0,  198,
-    0,  238,    0,    0,    0, 2124,    0,    0,    0,    0,
-    0,    0,    0,    0,  344,    0,    0,  591,    0,    0,
-  185,  194,   -8,    0,  190,    0,  128,  206,   89,10941,
-  251,  170,  263, 6477,    0,  170,  170,  170, -203,  170,
-  170,  613,    0,10036,  170,  170,    0,10036,    0,  278,
-    0,   89,    0,  170,  270,  170,    0,11436,11507,  306,
-  170,  170,    0,10036,    0,10711,10711,10711,10711,10711,
-10711,10711,10711,    0, -128,    0,11518,    0,    0,  272,
-  358,  595,  168,    0,    0,  339,    0,    0,    0,    0,
+  protected static readonly short [] yySindex = {         -140,
+    0, -179, -122, -206, -107,11604,    0,  -77,    0,    0,
+ -107, -206,    0,    0, -106,    0, 6451, -107,    0, -173,
+ -255,    0,    0,    0,    0,    0,    0,    0,    0,   22,
+    0,   41,    0,    0,    0, 4973,    0,    0,    0,    0,
+    0,    0,    0,    0,  125,    0,    0,  160,    0,    0,
+  -77,   70, -107,    0,  114,    0,  130,  248,  124,11086,
+  283,  180,   82, 6608,    0,  180,  180,  180, -159,  180,
+  180,  227,    0,10105,  180,  180,    0,10105,    0,  297,
+    0,  124,    0,  180,  463,  180,    0, 8157,11654,  299,
+  180,  180,10909,    0,10105,    0,10785,10785,10785,10785,
+10785,10785,10785,10785,    0,  294,    0,11678,    0,    0,
+  260,  375,  308,  118,    0,    0,  565,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0, 1011,    0,    0,
+  669,   98,  289,  605,  382,  567,  569,  594,  590,  439,
+  619,    0,    0,    0,    0,    0,    0, 3339,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  930,    0,  743,   72,
-  619,  634,  435,  311,  349,  356,  323,  -32,  359,    0,
-    0,    0,    0,    0,    0, 3174,    0,    0,    0,    0,
+    0,    0,  603,  670, -270,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0, -189, -186,   70,
+    0,  396,  652,  666,    0,  629,    0,    0,    0,    0,
+11678,11678,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  362,  387,   99,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0, -196, -181,  194,    0,  464,
-  498,  512,    0,  473,    0,    0,    0,    0,11518,11518,
+    0,    0,    0,    0,  704,  672,    0,  680,    0, -160,
+    0,    0,    0,   70,12518,   70,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  845,  701,10241,    0,
+    0,    0,    0,10105,  180,  180,  281,  308,    0,  709,
+    0,11678,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,  784,  117,11086,    0,11678,10105,  759,
+  779,10105,10105, 4541,  429, -196,  799,11732,   40,    0,
+  788,    0,  812,11678,10105,  825,  461,  180,    0,10105,
+  297, 9561,    0,    0,  463,10105,  463, -205,  416,  728,
+    0,  670,  118,  -69,  757,10105,10105,10105,    0, 6765,
+ -299,    0,    0,    0,    0,    0,    0,    0,    0,  827,
+10105,    0,    0,    0,  682,    0,    0,11509,  197,  839,
+  807,    0,  317,    0,    0,  354,    0,    0,  806,10241,
+ 9289,    0,    0,10785,10105,10105,10105,10105,10105,10105,
+10105,10105,10105,10105,10105,10785,10785,10785,11678,11678,
+10785,10785,10785,10785,10785,10785,10785,10785,10785,10785,
+10785,10785,10785,10785,10785,10785,10105,    0,    0,    0,
+    0,  670,    0,    0,    0,    0,11749,11803,  808,    0,
+    0,    0,    0,  -24,  714,    0,    0,    0,    0,    0,
+    0,    0,   70,   70,  811,    0,  816,    0,  807,  704,
+  704,    0, -146,    0,  528,  704,  869,    0, -180,12518,
+    0,    0,    0,    0, -156,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  101,12548,    0,
+    0,    0,  807,  206,    0,    0,  592,    0,  873,    0,
+  876, -100,  297,  180,    0,    0,  834, 7688, -246,    0,
+  878,    0,    0,    0,  895,  901,    0,  369,    0,  910,
+    0,  906,    0,    0,    0,  598,    0, 7824,  610,10105,
+  799, 9289,    0, 7236,    0,  463,    0,    0,    0,  913,
+  921,    0,    0,  124,  297,   61,    0, 4222,  922,    0,
+  923,  858,    0,  924,    0,10105,    0,    0, 1005,    0,
+    0,    0,10105, 1006,  928,    0,  931,  932,    0, -283,
+ 6765,    0,    0,    0,    0,    0,    0,    0,  929,  297,
+ 6765,    0,    0, -262,    0,    0,    0,  463,  197,  889,
+11827,    0,  935,    0,  939,10785,    0,  -96,    0,  247,
+    0,  807,  615,10105,10105,  941, 1059,    0,    0,   50,
+  942,    0,    0,    0,  669,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  539,  518,    0,  520,    0,   13,    0,    0,
-    0,  194,12469,  194,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  691,  554,10171,    0,    0,    0,
-    0,10036,  170,  170,  390,  595,    0,  567,    0,11518,
+    0,  669,  669,   98,   98,  289,  289,  289,  289,  605,
+  605,  382,  567,  569,  594,  590,    0,  944, -197,    0,
+10105,  -26,  899,   13,  903,  948,10105,    0,    0,    0,
+  964,    0,  481,  807,    0,    0,    0,    0,  586,  274,
+    0,11827,  528,    0,  950,  960,    0,    0,    0,    0,
+    0,    0,  197,  652,    0,  962,  961,    0,    0,    0,
+    0,  969,11877,  925,    0,  233,    0,    0,  110,    0,
+10241,    0,  966,    0,    0,    0,  628,  973,    0,  974,
+  975,  977,    0,    0,10105,    0,    0,  938,    0,    0,
+  981,    0,  979,10105, 1064,    0, 6608, 6608, 7983,    0,
+ 4541,    0,    0, 9697, -252,    0, -282, -184,    0,  930,
+  937,    0, -141,    0,    0,  991,    0,    0,    0,    0,
+    0,  992,    0, 1001,    0, 4381,    0,  297,    0,    0,
+  463,  394,  427,    0,  951,    0,  998,  999,    0, 6608,
+    0, 6608,    0,10105,    0,10105,11678,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0, 8140,    0,11678,
+    0,    0,  955,11509, 1031,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0, 9153,    0,    0,    0,    0,
+ 9425,10105,    0, 7393, 1002,    0,    0, 1081,    0, 1083,
+    0,  761,    0, 1004,10105,10105,  963,    0,    0,    0,
+    0,    0,  965,    0, -146,    0,    0,    0,    0,  528,
+  528,    0,  811, 1012, 1013,  967, 1019,  925,    0, 1014,
+    0, 1132, 1134,    0,    0,10105,    0, 9833, 1021,  628,
+11827,11678,    0,  -50, 1137, 1140, 1027, 1022,    0,10105,
+10105, 1028,10105, 1122,    0,    0,    0,    0,   60, 9969,
+    0,    0,    0,    0, 7529,    0, 1149,    0,  670,10105,
+ 1056, 7983, 1060,    0,    0, 1009,    0,    0,    0, 1015,
+  489,    0, 1018,    0, 1022,    0,    0,    0, 1052,    0,
+    0,    0,    0,    0,    0,    0,    0,  561,    0,    0,
+    0,11732,    0,    0, 1020, 1053, 1002,    0,10105,    0,
+10105,    0,10105,    0,    0,    0,    0,    0,    0,    0,
+    0,    0, 1061,  811,    0,    0,10377,    0,    0,    0,
+ 1066, 7253,    0,  925,    0,  925,    0,  925,    0,    0,
+    0,    0, 1024, 1067, 1021,    0,    0,    0, -155, -152,
+ 1070, 1074,    0,    0,    0,    0, 1073, 7983, 1002, -197,
+    0, 1078,    0,    0, 1085, 6608,    0,    0,    0,    0,
+    0,    0, 1080,    0,  799,    0,    0,    0,    0,    0,
+ -187,    0, 1086,  489,    0, 1034, 1002,    0,  297,    0,
+ 1036, 1079,    0,    0,    0,10105, 1114,10105,    0,10105,
+ 1111,  292,    0,  961,  184,  623,    0,    0,    0,    0,
+ -206,    0,    0,    0, 1096,    0,    0,    0, 1084,    0,
+    0,    0,  547,    0, 1087, 1210, 1211,    0,    0, 1097,
+ 1002,10105,    0,    0,    0,    0,    0,10105,    0, 1102,
+ -203,    0, -203,    0,    0,    0,    0, 1099,    0,10105,
+ 7393,    0,    0, 1125,  896, 1100,    0,10105,    0, 1103,
+    0,    0,10377, -107, -100,    0, 1101, 1101, 1101, 9833,
+ 1105,    0,10105,    0,    0,    0,    0, 1106,  979,    0,
+ 6608, 1107,    0,    0, 6765,    0, 1110,    0, 1113,    0,
+10105,    0,    0,    0,    0,    0,    0,10105,    0,    0,
+   70, 1109,   70, 7410, -145, -145, -145,    0,    0,10105,
+    0, 6608, 6608,    0,    0, 6765,    0,    0, 6608,    0,
+ 1136,10105,10105,    0,   70, 1117,    0, 1069,    0, 1116,
+    0,    0,    0, 1120,    0,    0, 1071,    0, 1156,    0,
+    0,    0,    0,    0,    0, 6765,    0,    0, 1164,    0,
+ 1112, -145,    0, 1145,   70, 7410, 1139, 1148,    0, 1151,
+ 1152, 1153,10105,    0,    0,    0,    0, 1135, 1112,    0,
+    0,11580,  -79,   70,    0,    0,    0, 1167,10105, 1144,
+10105,    0,    0, 1166,    0,    0, 1165,    0,    0,12548,
+    0, 1170,  -79,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,  462,12548,    0,    0,    0,    0,
+    0,    0,    0,    0,    0, 1172,   70,    0,   70, 1112,
+ 1123,    0, 1167,    0,    0, 1173,11580,11325,    0,    0,
+  479,    0,    0,    0,11357,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0, 1174,   70,    0,
+    0,    0,    0,    0,    0,11678,11678,  336,11732,  337,
+  463, 1207,    0,  197, 9089,    0, 1242,    0,    0, 1112,
+    0,    0,    0, 1112,    0,    0, 1131, 1133,    0,11678,
+ -151,    0,11678, 1133, 1138, 1184,    0,  197,    0, 1186,
+ 9021,    0, 1189, 1141,  -76,  509, 4973,    0,    0,    0,
+  197,    0, 1193, 1143, 1191, 1187,    0, 1195, 1198, 1199,
+ -100, 1190, 1202,    0, 1201, 1209,    0,  807,    0,  654,
+    0,    0,    0, 1206, -192,    0, 1197,    0,    0, 1212,
+    0,    0, 1213, 1215,    0, 1208,    0, -100, -100,    0,
+ -100, 1216, 1217,    0,    0,    0,    0, 1219,  -48,    0,
+ 1220, -100, 1327, 1221, -100, -100,  479,    0, 7983, 1179,
+ 1222, 1208,    0, 1224, 1228,   26, 1214,    0,    0, -100,
+ 9833, 1183, 1227, 1219,    0,    0,12548,    0,   70,   70,
+    0, 1188, 1229, 1220,    0, 1232,    0,10105, 1192, 1233,
+ 1221,    0, 1236, 1239,    0, -182,    0, 1237,    0,    0,
+    0,    0,    0,12548,    0,   26,   26, 1247, 1245,    0,
+ -192,    0,    0,   20, 1251,12548,    0,12548,    0,    0,
+ 7983, 1240,    0,    0,    0, 1252, 1212,    0,    0,    0,
+    0,    0, -144,    0,    0,    0, -145,  844, 1256,    0,
+    0,    0,    0,    0,    0,    0,    0, 1311, 1368,    0,
+    0,    0,    0, -145, 1261, 1262, 7983,    0,    0,    0,
+    0,   26,  529,  529,    0,    0,    0,    0,    0, -198,
+ -198,    0,    0,    0,    0,    0,    0, 9289, 9289,    0,
+    0,    0,    0,    0, 1266, 1264, 1265,    0,    0,    0,
+  };
+  protected static readonly short [] yyRindex = {         2824,
+    0,    0, 6922, 2824,    0,    0,    0, 1638,    0,    0,
+ 2977, 1029,    0,    0,    0,    0,    0, 2977,    0,    0,
+   43,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0, 1640,    0,    0, 1640,    0,    0,
+ 1638, 3020, 2871,    0,    0,    0,    0,    0,    0,    0,
+    0,    0, 1274,    0,    0,    0,    0,    0,    0,    0,
+    0,11901,    0, 1268,    0,    0,    0, 1268,    0,    0,
+    0,    0,    0,    0,  249,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  657,  117,10941,    0,11518,10036,  664,  672,10036,
-10036,  956,  400, -185,  689,11589,   78,    0,  706,    0,
-  711,11518,10036,  731,  540,  170,    0,10036,  278, 9496,
-    0,    0,  270,10036,  270, -132,  489,  666,    0,  387,
-  168, -103,  684,10036,10036,10036, 6633,  -52,    0,    0,
-    0,    0,    0,    0,    0,    0,  764,10036,    0,    0,
-    0, 4209,    0,    0,11354,  241,  798,  777,    0,  208,
-    0,    0,  264,    0,    0,  758,10171, 9226,    0,    0,
-10711,10036,10036,10036,10036,10036,10036,10036,10036,10036,
-10036,10036,10711,10711,10711,11518,11518,10711,10711,10711,
-10711,10711,10711,10711,10711,10711,10711,10711,10711,10711,
-10711,10711,10711,10036,    0,    0,    0,    0,  387,    0,
-    0,    0,    0,11600,11671,  793,    0,    0,    0,    0,
-    9,  808,    0,    0,    0,    0,    0,    0,    0,  194,
-  194,  796,    0,  821,    0,  777,  539,  539,    0, -147,
-    0,  651,  539,  825,    0, -200,12469,    0,    0,    0,
-    0, -173,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, -166,12504,    0,    0,    0,  777,
-  237,    0,    0,  560,    0,  881,    0,  886, -180,  278,
-  170,    0,    0,  849, 7550, -208,    0,  892,    0,    0,
-    0,  899,  900,    0,  233,    0,  906,    0,  903,    0,
-    0,    0,  638,    0, 7685,  654,10036,  689, 9226,    0,
- 7101,    0,  270,    0,    0,    0,  908,  909,    0,    0,
-   89,  278,  260,    0, 4367,  911,    0,  913,  860,    0,
-  918,    0,10036,    0,    0,  997,    0,    0,    0,10036,
-  998,  920,    0,  925,  926,    0, -259, 6633,    0,    0,
-    0,    0,    0,    0,    0,  923,  278, 6633,    0,    0,
-  144,    0,    0,    0,  270,  241,  882,11682,    0,  927,
-    0,  932,10711,    0,  319,    0,  377,    0,  777,  669,
-10036,10036,  931, 1048,    0,    0,   15,  933,    0,    0,
-    0,  743,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  743,  743,
-   72,   72,  619,  619,  619,  619,  634,  634,  435,  311,
-  349,  356,  323,    0,  934, -187,    0,10036,    6,  895,
-   48,  896,  929,10036,    0,    0,    0,  958,    0, -245,
-  777,    0,    0,    0,    0, -140,  286,    0,11682,  651,
-    0,  944,  946,    0,    0,    0,    0,    0,    0,  241,
-  498,    0,  948,  947,    0,    0,    0,    0,  951,11753,
-  910,    0,  205,    0,    0,  316,    0,10171,    0,  962,
-    0,    0,    0,  697,  957,    0,  970,  971,  972,    0,
-    0,10036,    0,    0,  936,    0,    0,  973,    0,  974,
-10036, 1052,    0, 6477, 6477, 7843,    0,  956,    0,    0,
- 9631,  355,    0, -236, -163,    0,  921,  928,    0,  -53,
-    0,    0,  983,    0,    0,    0,    0,    0,  982,    0,
-  990,    0, 7118,    0,  278,    0,    0,  270,  460,  553,
-    0,  940,    0,  991,  989,    0, 6477,    0, 6477,    0,
-10036,    0,10036,11518,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, 7999,    0,11518,    0,    0,  949,
-11354, 1020,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, 9091,    0,    0,    0,    0, 9361,10036,    0,
- 7257,  992,    0,    0, 1070,    0, 1073,    0,  735,    0,
-  995,10036,10036,  952,    0,    0,    0,    0,    0,  953,
-    0, -147,    0,    0,    0,    0,  651,  651,    0,  796,
- 1002, 1004,  961, 1013,  910,    0, 1006,    0, 1125, 1126,
-    0,    0,10036,    0, 9766, 1010,  697,11682,11518,    0,
- -231, 1130, 1131, 1017, 1009,    0,10036,10036, 1032,10036,
- 1124,    0,    0,    0,    0,  -89, 9901,    0,    0,    0,
-    0, 7392,    0, 1153,    0,  387,10036, 1044, 7843, 1045,
-    0,    0,  994,    0,    0,    0,  999, -117,    0, 1001,
-    0, 1009,    0,    0,    0, 1043,    0,    0,    0,    0,
-    0,    0,    0,    0,  696,    0,    0,    0,11589,    0,
-    0, 1005, 1049,  992,    0,10036,    0,10036,    0,10036,
-    0,    0,    0,    0,    0,    0,    0,    0,    0, 1054,
-  796,    0,    0,10306,    0,    0,    0, 1055, 7274,    0,
-  910,    0,  910,    0,  910,    0,    0,    0,    0, 1011,
- 1051, 1010,    0,    0,    0, -169, -157, 1060, 1061,    0,
-    0,    0,    0, 1064, 7843,  992, -187,    0, 1065,    0,
-    0, 1071, 6477,    0,    0,    0,    0,    0,    0, 1072,
-    0,  689,    0,    0,    0,    0,    0, -205,    0, 1079,
- -117,    0, 1031,  992,    0,  278,    0, 1033, 1074,    0,
-    0,    0,10036, 1109,10036,    0,10036, 1106,  334,    0,
-  947,  451,  725,    0,    0,    0,    0, -184,    0,    0,
-    0, 1095,    0,    0,    0, 1083,    0,    0,    0,  532,
-    0, 1084, 1209, 1210,    0,    0, 1096,  992,10036,    0,
-    0,    0,    0,    0,10036,    0, 1102, -194,    0, -194,
-    0,    0,    0,    0, 1099,    0,10036, 7257,    0,    0,
- 1129,  762, 1098,    0,10036,    0, 1103,    0,    0,10306,
-   -8, -180,    0, 1104, 1104, 1104, 9766, 1108,    0,10036,
-    0,    0,    0,    0, 1111,  974,    0, 6477, 1105,    0,
-    0, 6633,    0, 1107,    0, 1115,    0,10036,    0,    0,
-    0,    0,    0,    0,10036,    0,    0,  194, 1119,  194,
- 7567, -150, -150, -150,    0,    0,10036,    0, 6477, 6477,
-    0,    0, 6633,    0,    0, 6477,    0, 1132,10036,10036,
-    0,  194, 1128,    0, 1075,    0, 1118,    0,    0,    0,
- 1133,    0,    0, 1080,    0, 1160,    0,    0,    0,    0,
-    0,    0, 6633,    0,    0, 1156,    0, 1134, -150,    0,
- 1138,  194, 7567, 1136, 1141,    0, 1145, 1147, 1148,10036,
-    0,    0,    0,    0, 1137, 1134,    0,    0,10782,  -79,
-  194,    0,    0,    0, 1158,10036, 1143,10036,    0,    0,
- 1149,    0,    0, 1150,    0,    0,12504,    0, 1154,  -79,
+    0,    0,    0,    0,    0, 3651,    0,    0,    0,    0,
+    0,  288, 4539, 3810,    0,    0, 4380,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  452,12504,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, 1155,  194,    0,  194, 1134, 1114,    0, 1158,
-    0,    0, 1157,10782,11126,    0,    0,  485,    0,    0,
-    0,11194,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, 1165,  194,    0,    0,    0,    0,
-    0,    0,11518,11518,  300,11589,  342,  270, 1183,    0,
-  241, 8991,    0, 1220,    0,    0, 1134,    0,    0,    0,
- 1134,    0,    0, 1116, 1117,    0,11518, -149,    0,11518,
- 1117, 1135, 1166,    0,  241,    0, 1178, 9021,    0, 1181,
- 1139,   14,  528, 2124,    0,    0,    0,  241,    0, 1185,
- 1142, 1184, 1180,    0, 1197, 1200, 1211, -180, 1173, 1232,
-    0, 1235, 1241,    0,  777,    0,  789,    0,    0,    0,
- 1239, -160,    0, 1231,    0,    0, 1244,    0,    0, 1243,
- 1247,    0, 1242,    0, -180, -180,    0, -180, 1248, 1249,
-    0,    0,    0,    0, 1250,   56,    0, 1256, -180, 1366,
- 1259, -180, -180,  485,    0, 7843, 1224, 1267, 1242,    0,
- 1272, 1273,   58, 1277,    0,    0, -180, 9766, 1236, 1281,
- 1250,    0,    0,12504,    0,  194,  194,    0, 1240, 1283,
- 1256,    0, 1290,    0,10036, 1251, 1291, 1259,    0, 1294,
- 1296,    0, -168,    0, 1289,    0,    0,    0,    0,    0,
-12504,    0,   58,   58, 1304, 1300,    0, -160,    0,    0,
- -151, 1305,12504,    0,12504,    0,    0, 7843, 1293,    0,
-    0,    0, 1306, 1244,    0,    0,    0,    0,    0, -129,
-    0,    0,    0, -150,  843, 1310,    0,    0,    0,    0,
-    0,    0,    0,    0, 1365, 1418,    0,    0,    0,    0,
- -150, 1313, 1326, 7843,    0,    0,    0,    0,   58,  555,
-  555,    0,    0,    0,    0,    0,  -83,  -83,    0,    0,
-    0,    0,    0,    0, 9226, 9226,    0,    0,    0,    0,
-    0, 1331, 1328, 1332,    0,    0,    0,
-  };
-  protected static readonly short [] yyRindex = {         2744,
-    0,    0, 6789, 2744,    0,    0,    0, 1702,    0,    0,
- 2899, 2675,    0,    0,    0,    0,    0, 2899,    0,    0,
-   44,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0, 4695,    0,    0,
+ 4763, 5107, 5311, 5651, 5855, 5991, 6127,  758, 6263, 1178,
+  519,    0,    0,    0,    0,    0,    0,   43,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, 1706,    0,    0, 1706,    0,    0,
- 1702,  307, 2787,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, 1341,    0,    0,    0,    0,    0,    0,    0,
-    0,11764,    0, 1333,    0,    0,    0, 1333,    0,    0,
-    0,    0,    0,    0,  231,    0,    0,    0,    0,    0,
+    0,    0,    0, 1230,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  911,  911, 3087,
+    0,  505, 1269,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, 3642,    0,    0,    0,    0,    0,
-  301, 4366, 3800,    0,    0, 4208,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0, 4521,    0, 4588, 4928,
- 5129, 5464, 5665, 5799, 5933, 1046, 4451, 6201, 2295,    0,
-    0,    0,    0,    0,    0,   44,    0,    0,    0,    0,
+    0,    0,    0,    0, 1640,  252,    0,    0,    0,    0,
+    0,    0,    0, 3150,  290, 3197,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, 1292,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  776,  776, 2942,    0,  149,
- 1335,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0, 3426,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, 1706,  113,    0,    0,    0,    0,    0,    0,
-    0, 3009,  708, 3052,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, 3260,    0,    0,    0,    0,    0,
+    0,    0,    0, 1278,    0,    0,    0,    0, 3426,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0, 1935,    0, 2484,  380, 2065,    0,
+    0, 2212, 2065,  380,    0,    0,    0,    0,    0, -242,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+ 1268,    0,    0,    0,    0,    0,    0, 1270, 2337,    0,
+ 3426,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   77,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, 1344,    0,    0,    0,    0, 3260,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, 1806,    0, 2338,  385, 1935,    0,    0, 2064,
- 1935,  385,    0,    0,    0,    0,    7,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0, 1333,    0,    0,
-    0,    0,    0,    0, 1342, 2193,    0, 3260,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,   26,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0, 1318,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,   52,    0,    0,    0,    0,    0,
+    0,    0, 3260, 2642,    0,    0,    0,    0, 1782, 1640,
+ 1640,    0, -124,    0, 7705, 1640, 1647,    0,    0,  201,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  278,11018,    0,
+    0,    0, 3426, 3969,    0,    0,    0,    0,    0,    0,
+    0,11401,    0,    0,    0,    0,    0, 1273,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  854, 1033,    0,
+    0, 1282,    0,    0,    0,    0,    0,  -40,    0,    0,
+ 3903, 1280,    0,    0,    0,  284,    0,    0,    0,    0,
+    0,    0,    0,    0,    0, 1486,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0, 1191,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   23,    0,    0,    0,    0,    0,    0,    0, 3095,
- 2495,    0,    0,    0,    0, 1654, 1706, 1706,    0, -215,
-    0, 7860, 1706, 1712,    0,    0,  218,    0,    0,    0,
+    7,    0,    0,    0,    0,    0,    0,    0,    0, 8297,
+    0,    0,    0,    0,    0,    0,    0,   47,  419,    0,
+    0,    0, 1283,    0,    0,    0,    0, 3426,    0, 3426,
+    0, 4062,    0,    0,    0,  -35,    0,    0,    0,    0,
+   92,    0,    0,    0, 4867,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  338,10859,    0,    0,    0, 3260,
- 3958,    0,    0,    0,    0,    0,    0,    0,11226,    0,
-    0,    0,    0,    0, 1339,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  712,  786,    0,    0, 1348,    0,
-    0,    0,    0,    0,   12,    0,    0, 3734, 1345,    0,
-    0,    0,  322,    0,    0,    0,    0,    0,    0,    0,
-    0,    0, 1360,    0,    0,    0,    0,    0,    0,    0,
+    0, 4935, 5039, 5175, 5243, 5379, 5447, 5515, 5583, 5719,
+ 5787, 5923, 6059, 6195,  830, 6319,    0,    0,  632,    0,
+    0,  380,    0,  380,    0,    0,    0,    0,    0,    0,
+ 2299,    0,    0, 1782,    0,    0,    0,    0, 1241,    0,
+    0,    0,11955,    0,    0,  645,    0,    0,    0,    0,
+    0,    0,  706, -249,    0,    0, 1288,    0,    0,    0,
+    0, 1293,    0,    0,    0,    0,    0,    0,10513,    0,
+    0,    0,  644,    0,    0,    0,11972,    0,    0,  663,
+  691,  702,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0, 1285,    0,    0,    0,    0,    0,    0,    0,
+ 1295,    0,    0,    0, 3492,    0,    0,   18,    0,   67,
+ 3585,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0, 1307,    0,    0,    0,    0,    0,    0,    0,    0,
+  258,  478,  551,    0,    0,    0,    0, 1304,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,   17,    0,    0,
-    0,    0,    0,    0,    0,    0, 8155,    0,    0,    0,
-    0,    0,    0,    0, -189,  285,    0,    0,    0, 1346,
-    0,    0,    0,    0, 3260,    0, 3260,    0, 3892,    0,
-    0,    0,   94,    0,    0,    0,    0,   95,    0,    0,
-    0, 4691,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0, 4758, 4861,
- 4995, 5062, 5196, 5263, 5330, 5397, 5531, 5598, 5732, 5866,
- 6000, 6067, 6134,    0,    0,  771,    0,    0,  385,    0,
-  385,    0,    0,    0,    0,    0,    0, 3538,    0,    0,
- 1654,    0,    0,    0,    0, 1301,    0,    0,    0,11835,
-    0,    0,  794,    0,    0,    0,    0,    0,    0,  740,
-  496,    0,    0, 1350,    0,    0,    0,    0, 1357,    0,
-    0,    0,    0,    0,    0,10441,    0,    0,    0,  782,
-    0,    0,    0,11846,    0,    0,  799,  811,  814,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0, 1349,
-    0,    0,    0,    0,    0,    0,    0, 1358,    0,    0,
-    0, 3326,    0,    0,   53,    0,   61, 3418,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0, 1361,    0,
-    0,    0,    0,    0,    0,    0,    0,  177,  587,   65,
-    0,    0,    0,    0, 1362,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  159,    0,    0,
-    0, 1354,    0,    0,    0,    0,    0,    0,  439,    0,
-  596,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, -215,    0,    0,    0,    0,11846, 8016,    0, 1363,
-    0,  680,    0,    0,    0,    0, 1368,    0, 1314, 1323,
-    0,    0,    0,    0,    0, 1367,11917,    0,    0,    0,
-11310,    0,    0,    0,  815,    0, 1369,    0,    0,    0,
- 1526,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0, 3576,    0, 4050, 1374,    0,
-    0,    0, 1375,    0,    0,    0,    0,  587,    0,    0,
-    0,  815,    0,    0,    0,    0,    0,    0,    0,    0,
+   97,    0,    0,    0, 1301,    0,    0,    0,    0,    0,
+    0,  366,    0,  562,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0, -124,    0,    0,    0,    0,11972,
+ 8000,    0, 1308,    0,  622,    0,    0,    0,    0, 1312,
+    0, 1277, 1291,    0,    0,    0,    0,    0, 1306,12026,
+    0,    0,    0,11477,    0,    0,    0,  770,    0, 1322,
+    0,    0,    0, 1653,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0, 3744,    0,
+ 4221, 1315,    0,    0,    0, 1360,    0,    0,    0,    0,
+  478,    0,    0,    0,  770,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  683,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  591,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  816,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  773,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, 1372,    0,    0,    0,    0,    0,  829,  830,    0,
-    0,    0,    0,    0,    0, 1377,  771,    0,    0,    0,
+    0,    0,    0,    0, 1357,    0,    0,    0,    0,    0,
+  781,  792,    0,    0,    0,    0,    0,    0, 1363,  632,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0, 3734,    0,    0,    0,    0,    0, 1382,    0,    0,
-  587,    0,  846, 1377,    0, 8155,    0,  542,  621,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,   42,    0,
- 1350, 8205,    0,    0,    0,    0,    0,11948,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  726,
-    0,  751,    0,    0,    0,    0,    0, 1354, 1379,    0,
-    0,    0,    0,    0,    0,    0,    0, 1386,    0, 6945,
+    0,    0,    0,    0, 3903,    0,    0,    0,    0,    0,
+ 1316,    0,    0,  478,    0,  885, 1363,    0, 8297,    0,
+  456,  631,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,  139,    0, 1288, 2402,    0,    0,    0,    0,    0,
+12068,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,  656,    0,  678,    0,    0,    0,    0,    0,
+ 1301, 1365,    0,    0,    0,    0,    0,    0,    0,    0,
+ 1319,    0, 7079,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,  468,  593,    0,    0,    0,    0,
+    0,    0,    0,12144,11401,    0,   73,   73,   73,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  950,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  461,  649,    0,    0,    0,    0,    0,    0,    0,
-12016,11226,    0, -161, -161, -161,    0,    0,    0,    0,
-    0,    0,    0,    0,    0, 1383,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,12170,    0, -242,
-    0, 1389, 1389, 1389,    0,    0,    0,    0,    0,    0,
-    0,    0, -214,    0,    0,    0,    0,    0,    0,    0,
-    0,12213,    0,    0,    0,    0, 1390,    0,    0,    0,
-   21,    0,    0,    0,    0,  561,    0,    0,    0,    0,
-    0,    0, 1391,    0,    0,    0,    0, 2830, 1381,  404,
-    0,  127,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0, 2607,    0,    0,    0, 8358,
- 8722,    0,    0,    0,  713,    0,    0,    0,    0,    0,
-    0,    0,    0,  420,    0,    0,11012,    0,    0, 8449,
+12249,    0, -278,    0, 1372, 1372, 1372,    0,    0,    0,
+    0,    0,    0,    0,    0, -219,    0,    0,    0,    0,
+    0,    0,    0,    0,12292,    0,    0,    0,    0, 1376,
+    0,    0,    0,  147,    0,    0,    0,    0,  554,    0,
+    0,    0,    0,    0,    0, 1377,    0,    0,    0,    0,
+ 2934, 1364,  365,    0,  217,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0, 2761,    0,
+    0,    0, 8457, 8853,    0,    0,    0,  688,    0,    0,
+    0,    0,    0,    0,    0,    0,  395,    0,    0,11183,
+    0,    0, 8556,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,11251,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0, 8947,    0, 8655, 2761,
+    0,    0,  688,    0,    0,    0,    0,  278,    0,    0,
+    0,    0,    0,    0,  278,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0, 8754,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,11094,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0, 8813,    0, 8540, 2607,    0,    0,  713,
-    0,    0,    0,    0,  338,    0,    0,    0,    0,    0,
-    0,  338,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0, 8631,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0, 8926,  340,    0,
- 8857,    0,    0,    0, 8956,    0, 2607,    0,    0,    0,
- 2607,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  770,    0, 1393,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  801,    0,  661,
-    0,    0,    0,    0,    0,    0,    0,11226,  841,    0,
-    0,    0,    0,    0, 1388,    0,  870,    0,    0,    0,
-    0,    0,    0,  864,    0,    0,    0,    0,    0,    0,
-    0,    0, 1387,    0,11226,11226,    0,11270,    0,    0,
-    0,    0,    0,    0, 1392,12439,    0, 1394,11226,10576,
- 1395,11226,11226,    0,    0,    0,    0,    0, 1396,    0,
-    0,    0,12380,    0,    0,    0,11226,    0,    0,    0,
- 1397,    0,    0,   70,    0, 4526,12350,    0,    0,    0,
- 1398,    0,    0,    0,    0,    0,    0, 1399,    0,    0,
-    0,    0,  603,    0,  873,    0,    0,    0,    0,    0,
-  861,    0,12256,12291,    0,    0,    0,    0,    0,    0,
-    0,    0, 1446,    0, 1500,    0,    0,    0,  874,    0,
+ 4669,  306,    0, 8989,    0,    0,    0, 9059,    0, 2761,
+    0,    0,    0, 2761,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  868,    0, 1379,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  643,    0,    0,    0,    0,    0,    0,
+  908,    0,  602,    0,    0,    0,    0,    0,    0,    0,
+11401,  794,    0,    0,    0,    0,    0, 1375,    0,  718,
+    0,    0,    0,    0,    0,    0,  815,    0,    0,    0,
+    0,    0,    0,    0,    0, 1373,    0,11401,11401,    0,
+11433,    0,    0,    0,    0,    0,    0, 1382,12478,    0,
+ 1391,11401,10649, 1392,11401,11401,    0,    0,    0,    0,
+    0, 1393,    0,    0,    0,12448,    0,    0,    0,11401,
+    0,    0,    0, 1394,    0,    0,  105,    0,10940,12410,
+    0,    0,    0, 1396,    0,    0,    0,    0,    0,    0,
+ 1403,    0,    0,    0,    0,  583,    0,  818,    0,    0,
+    0,    0,    0,  898,    0,12334,12372,    0,    0,    0,
+    0,    0,    0,    0,    0, 1440,    0, 1517,    0,    0,
+    0,  819,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  588,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,  588,    0,    0,    0,    0,    0,    0,
+    0,12448,10821,12186,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0, 1280, 1280,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  643,    0,    0,    0,    0,    0,    0,    0,12380,12059,
-12102,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, 1345, 1345,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,
   };
   protected static readonly short [] yyGindex = {            0,
-    0, 1713,    0,    0,    0,    2,  -16, -177,  -42, 1714,
-    0, 1753, 1763,   81,    0,    0,    5,    0,    0,    0,
-    0,    0,    0, -832, -680, -220, -565,    0,    0,    0,
-    0,    0, -176,    0,    0,    0,  869,    0,  965,    0,
-    0,    0,    0,  734,  736,  -17, -229,    0,    0,    0,
-    0,  605, -604, -407, -368, -322, -318, -302, -254, -253,
- -869,-1115,    0,    1,    0,  173,    0,-1058,    0,    0,
-    0,    0,    0,    0,  551,  -48,  391,    0,    0,    0,
-  434,-1023,    0, -273, -294, 1152,    0,    0,    0, -856,
-  384,    0,    0, -488,    0,    0,  458,    0,    0,  430,
-    0,    0,  465,    0, -246, -592,    0,    0,    0,    0,
-  558,  -14,    0,    0,  988,  993,  996, 1146, -515,    0,
-    0, -308, 1007,  557,    0,-1304,    0,    0,    0,    0,
-    0,    0,    0,    0,  365,    0,    0,    0,    0,    0,
-    0,    0,    0,  627,    0,    0,    0,    0, -317,  548,
+    0, 1732,    0,    0,    0,   -2,   -9, -178,  -42, 1735,
+    0, 1772, 1786,  568,    0,    0,   -7,    0,    0,    0,
+    0,    0,    0, -780, -685, -216, -600,    0,    0,    0,
+    0,    0, -190,    0,    0,    0,  879,    0,  982,    0,
+    0,    0,    0,  739,  741,  -17, -229,    0,    0,    0,
+    0,  613, -662, -625, -592, -518, -515, -471, -465, -453,
+-1096,-1093,    0,    1,    0,  211,    0,-1034,    0,    0,
+    0,    0,    0,    0,  558,  -74,  397,    0,    0,    0,
+  435,-1025,    0, -273, -291, 1146,    0,    0,    0, -859,
+  384,    0,    0, -493,    0,    0,  451,    0,    0,  425,
+    0,    0,  460,    0, -391, -931,    0,    0,    0,    0,
+  570,  -14,    0,    0,  988,  990,  994, 1155, -523,    0,
+    0, -312, 1003,  566,    0, -940,    0,    0,    0,    0,
+    0,    0,    0,    0,  368,    0,    0,    0,    0,    0,
+    0,    0,    0,  630,    0,    0,    0,    0, -301,  548,
     0,    0,    0,    0,    0,    0,    0,    0,    0,  641,
-    0, -491,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  383,    0,    0,  466,    0,    0,  469,  472,  388,
-    0,    0,    0,    0,    0,    0,    0,    0,  699,    0,
-    0,    0,    0,  -64,    0,  216,  -96,    0,    0,  536,
-    0,  594,    0, 1047,    0, 1347, -292, -270,  -58,  162,
-    0,  704,    0,  -31,  -12,    0,    0,  474,    0,    0,
+    0, -494,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,  383,    0,    0,  465,    0,    0,  470,  472,  388,
+    0,    0,    0,    0,    0,    0,    0,    0,  698,    0,
+    0,    0,    0,  -58,    0,  318,  -55,    0,    0,  534,
+    0,  595,    0, 1043,    0, 1333, -293, -269,  -62,  162,
+    0,  710,    0,  -39,   54,    0,    0,   -5,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0, -263,    0,  129,    0,    0, -327,
+    0,    0,    0,  997,    0, -300, -134, 1154, 1091,    0,
+ 1088,    0, 1284, 1495, 1200,    0,    0,  909, 1788,    0,
+    0,    0,    0, 1160,    0,    0,    0,    0,    0, -504,
+    0,    0,    0,    0, 1775, 1115,    0,    0,  480,  904,
+  752,  902, 1482, 1483, 1484, 1487, 1481,    0, 1488,    0,
+    0,    0, 1118,    0,  907,    0,    0,    0,    0,    0,
+    0,    0,    0, -286,    0,    0,    0,    0, -442,    0,
+  751,    0,  668,    0,  747,    0,    0,    0,  813, -519,
+  -16, -305,  -13,    0, 1729,    0,   25,    0,   27,   58,
+   90,  106,  115,  119,  120,  121,  134,  144,    0, -658,
+    0,  -32,    0,    0,  940,    0, -455,    0,    0,    0,
+  848,    0,  995,    0,  956, -449,    0,    0,    0,    0,
+    0,    0,  862,    0,    0,  861,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  874,    0,    0,
+    0,    0,    0,    0,    0,    0,  -37,    0, 1381,    0,
+    0,    0, 1023,    0,    0,    0,    0,    0, -170,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0, -266,    0,  637,    0,    0, -522,
-    0,    0,    0, 1012,    0, -301, -125, 1164, 1100,    0,
- 1090,    0, 1297, 1515, 1206,    0,    0,  914, 1803,    0,
-    0,    0,    0, 1179,    0,    0,    0,    0,    0, -776,
-    0,    0,    0,    0,    0,   20,    0,  484,  883,  690,
-  868, 1490, 1491, 1489, 1492, 1493,    0, 1488,    0,    0,
-    0, 1121,    0,  915,    0,    0,    0,    0,    0,    0,
-    0,    0, -268,    0,    0,    0,    0, -441,    0,  763,
-    0,  670,    0,  757,    0,    0,    0,  822, -518,   -1,
- -305,    4,    0, 1739,    0,   55,    0,   63,   67,   68,
-   83,   84,   86,  115,  119,  123,  124,    0, -590,    0,
-  -28,    0,    0,  950,    0, -848,    0,    0,    0,  862,
-    0, 1014,    0,  966, -456,    0,    0,    0,    0,    0,
-    0,  871,    0,    0,  876,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  888,    0,    0,    0,
-    0,    0,    0,    0,    0,  -36,    0, 1400,    0,    0,
-    0, 1040,    0,    0,    0,    0,    0, -170,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0, 1502,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  709,
-    0,    0,    0,    0,    0,    0,    0,    0,  810,    0,
-    0,    0,    0,    0,    0,  -10, 1113,    0,    0,    0,
- 1120,
+ 1480,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+  686,    0,    0,    0,    0,    0,    0,    0,    0,  787,
+    0,    0,    0,    0,    0,    0,   31, 1090,    0,    0,
+    0, 1092,
   };
-  protected static readonly short [] yyTable = {           108,
-  502,  188,  109,  505,  113,   18,   44,  713,  344,  233,
-  420,  438,  718,  478,  664,  154,  419,  463,  686,  750,
-  155,  541,  532,  498,  191,  486,  312,  559,  256,  756,
-  395,  258,  978, 1095, 1128, 1129,  558,  229,  860,  318,
-  323,  304,  760,  923,  251,  521,  351,  113,  359,  527,
- 1024,  113,  352,  783,  360,  647,  298,  458,  347,  402,
-  298, 1215, 1025,   14,  287,  305,  374,  307,  780,  189,
-  494,  159,  288, 1025,  402,  672,  328, 1222,   48,  160,
- 1154,  648,  657,  161,  162,  691, 1009, 1419, 1427, 1428,
-   48,  972,  851,   20,  660, 1333,    1, 1017, 1011,  163,
-  164,  197,  165,  841,  842, 1123, 1293,  747,  635,  938,
-  660, 1432,  360,  649,  661,  329,  330,  331,  332,  333,
-  334,  335,  336,  804,  326, 1035,  424,  463,  617,  796,
-  848,  166,   16,  197, 1442,  167,  231,  337,  108,  168,
-  169,  109,  403,  113, 1459,  233,  871,  404,  873,  405,
-  427,  428,  783,  798,  154,  406,  407,  403,  344,  155,
-  673,  523,  404, 1433,  405,  799,  855,   45,  748, 1064,
-  406,  407, 1467,    2,   48,  662, 1176,  660,  111,  374,
-  495,  374,  496,  374,  249,  338,  196,  231, 1124,  437,
-  530,  849,  781,  707, 1033, 1443, 1034,  731,    2,  438,
-  344,   48,  855,  711,  660, 1420,  783,  843,  692,  852,
-  159,  468,  429,  289,  339, 1026,  650,    6,  160, 1334,
-  231,  111,  161,  162,   15,  111, 1026,  374,  435,  462,
-  190,  408,  541,  250,  466,  194,  497,  476,  163,  164,
-  559,  165,  541,  658,  458,  340,  418, 1010, 1401,  321,
-  321,  564,  256,  507,  520,  474,  528,  341,  525, 1012,
-  256,  341,  529,    3,    4,    5,    6, 1294,  321,  477,
-  166,  113,  481,  483,  167, 1425,  661,  954,  168,  169,
-  342,  519,   93,  857,  342,  508,  341, 1435,  231, 1436,
-  516, 1468,  518,  550,  517,  342,  481,  113,  343,  784,
-  923,  546,  865,  194,  194, 1153,    5,  534,  535,  342,
- 1047, 1363,  936, 1390,  113,  856,  923,  111,  543,  857,
-  298,  559,  194, 1169,  956,  540,   20,  597,  598,  632,
-  542,  805,  641,  376, 1397,  965, 1234,  434, 1306,  462,
-  575,  786,  731,  533,  583,  584,  585,  586,  587,  588,
-  589,  590,  591,  592,  593,  620,  622,  625,  626,  661,
-  321,  321, 1021,  665,  344, 1445, 1234,  392,  360,  377,
-  966,  877,  877,  684, 1238,  544,  615,  233,  449,  393,
-  533,  950, 1453,  685,  641,  775,  661,  636,  344, 1268,
-  876,  876,  594,  595,  596,  341,  461,  533,  533,  533,
-  533,  533,  533,  533,  533,  533,  533,  533,  533,  533,
-  533,  533,  533,  834,  194,  194,  633,  634,  342,  450,
-  339,  321,  645,  231, 1285,  231,  630,  923, 1286,   43,
- 1307,  486,  338,  923,  684,  338,  627,  341,  463,  449,
-  651,   49,  776,  559,  685,  111,  685,  321,  378,  379,
-  877,  360,  558,  461,   93,  681, 1016,  321,  249, 1089,
-  342,   55,  113,  321,  628,  462,  628,  341,  765,  876,
-  767,  111,  768,  400,    6,  194,  818, 1101,  360,  709,
-  450,  575,  360,  716,  360,  360,  360,  360,  111,  641,
-  342,  472,  360,  328,  641,  245,  722,  724,  641,  246,
-  819,  194,  199,  321,  343,  740,  321,  250, 1131, 1132,
-  559,  194,  742,  641,  533, 1134,  757,  194,  934,  730,
-  345,  628,  462,  345,  349,  113,  401,  820,  511,  466,
-  929,  466,  752,  257,  797,  113,  540,  321,  321,  249,
-  641,  542,  200,   48,  473,  725,  540,  367,  886,  247,
-  707,  542,  311,  770,  770, 1266, 1195,  194,  758,  641,
-  194,  231,  686,    5,  244,  321,  321,   48,  948,  257,
-  257,  257,  257,  257,  257,  257,  257,  372,   48,  339,
-  248,  853,  763,   48,  750,  961,  466,   48,  250,  402,
-   48,  194,  194,  367, 1178, 1194,  505, 1269,  737, 1195,
-  783, 1226,   48,   48, 1267,  344,  789,   48,   48,  639,
-  666,  640,  696,   48, 1178,   48,   48,   48,   48,  194,
-  194,  821,  341,   48,  565,  259,  341,   48,  822,   48,
-  341, 1226,  261,  639,  566,  640,  111,  194, 1194,   48,
- 1225,  345,   48,   93,   48,  342, 1270,  737,   48,  342,
-  462,  194,  345,  342,  311,  609,  345,  609,  802,  343,
-  639,  817,  640,  343,  481,   48,  256,  711,  338,  345,
- 1225,  525,  403,  839,  863,  324,  321,  404,  716,  405,
-  567,  113,  113,  709,  997,  406,  407,  372,  348,  372,
-  568,  372,  372,  388,  372,  876,  372,  339,  260,  111,
-  803,  345,  284,  285,  286, 1321,  290,  291,  880,  111,
-  864,  302,  303,  225,  349,  226,  361,  338,  308,  321,
-  310,  391,  314,  874,  113,  875,  113,  325,  326,  350,
-  732,  342, 1351, 1352,  847, 1354,  389,  878,  372,  390,
-  372,  345,  311,  372,  341,  764, 1373,  394,  358, 1380,
- 1381, 1069,  345, 1196,  293,  575,  345,  257,  667,  636,
-  575,  888,  929,  716, 1396,  257,  541,  342,  491,  345,
-  331,  632,  492,  194,  904,  905,  331,  907,  397,  341,
-  937,  343,  907,  332,  907,  667, 1098,  907,  907,  342,
-  907,  907, 1197,  339,  667,  510, 1196,  541, 1227,  910,
-  321,  345,  342,  766,  910,  926,  910,  477,  511,  910,
-  910,  907,  910,  910,  651,  918,  343, 1104, 1046,  481,
-  997,  321,  952, 1130,  666,  512, 1219,  541, 1227,  955,
- 1048,  386,  387,  910,  257, 1197,  664, 1228, 1198,  963,
-  341,  716, 1199,  422,  582,  349,  257,  257,  257,  341,
-   93,  257,  257,  341,  194,  111,  111, 1384, 1200, 1258,
-  424,  599,  600,  342,   65,   65,  907, 1228,   65,  424,
- 1001,  533,  342,  311,  797,  194,  342,  343,  982,  865,
-  984, 1198,  986, 1229,  321, 1199,  425, 1230,  910,  426,
-  308,  438,  358,   93, 1212,  344,  996, 1255,  111, 1058,
-  111, 1200, 1308, 1231, 1255,  321, 1201, 1202,  225,  349,
- 1112, 1059,  763, 1229,  763,  651,  763, 1230,  321, 1437,
-   93, 1003,  321, 1004,  867, 1005,  663,  716,  667, 1152,
-  499,  430,  668, 1231,  901,  663,  433,  311,  194,  901,
-  113,  901,  515,  345,  901,  901,  459,  901,  901, 1201,
- 1202, 1232, 1233,  505,  345, 1456,  552,  345,  345,  194,
-  225,  752,  228,  553,  249, 1039,  353, 1041,  282, 1042,
-  460,  345,  194, 1473, 1474,  554,  194,  282,  292,  641,
-  293, 1232, 1233,  467,  641,  354,  355,  903,  641,  321,
-  321,  752,  903,  752,  903,  752,  471,  903,  903, 1051,
-  903,  903,  552,  641,  827,  356,  699,  477,  662,  553,
-  700,  380,  381,  250,  382,  383,  357,  662, 1289, 1076,
-  716,  554,  708,  901, 1296,  194,  492, 1083,  384,  385,
-  641, 1302,  996,  291, 1088,  291,  257,  769,  479,  477,
-  291,  668,  477,  194,  194,  233,  480, 1115,   66,  641,
-  321,  897,   66,  749,  501,  113,  897,  749,  897,  113,
- 1108,  897,  897,  929,  897,  897,  977, 1111,  778,  233,
-  540,  603,  604,  605,  606,  542,  903,  350,  507,  477,
-  321,  345,  526,  345,  507,  506,  113,  113,  901,  902,
-  113, 1136, 1042,  113,  181, 1049,  181, 1050,  181, 1115,
-  531,  540,  345,  345,  194,  509,  542,  682,  345,  345,
- 1173,  345,  345,   57,  111, 1080, 1081, 1177, 1193,  193,
-  113,  193,  345,  193,  876,  876,  194,  373,  374,  375,
-  345,  540, 1165,  345,  194,  350,  542, 1177,  545,  350,
-  897,  345,  130,  745,  130,  745,  403,  723, 1210,  130,
-  477,  404,  508,  405,  754,  424,  754,  424,  508,  406,
-  407, 1193,  943, 1177,  943, 1173,  350,  169,  563,  169,
-  350,  257,  345,  350,  569,  350,  424,  424, 1300,  176,
-  350,  176,  177,  350,  177,  854,   68,  854,   68,  342,
-  512, 1300,  646, 1177, 1264, 1265,  424,  199,  170,  199,
-  170,  342,  430, 1260,  424, 1446, 1447,  424, 1329,  623,
- 1330,  484,  346,  135,  350,  135,  531,  531, 1292,   57,
-   25, 1295,   26,  641,  641,   27,  253, 1093, 1094,  111,
-   28,   62,   63,  111,   29,  360,  296,  631,  296,  360,
-   65,  345,  360,   31,  360,  142,  303,  142,  303,  360,
-   33,  669,  321,  607,  608,   34,  671,   72,   73,   35,
-  111,  111,  601,  602,  111,  683,  693,  111, 1309,  694,
-  695,   37,  697,   38,   75,  698,  738,   39,  720,  721,
-   77,  736,   79,  737,   81,   40,   41,  254,  739,   42,
-  741,  743,  744, 1364,  111,  745,  746,  751,  759,  761,
-  773,  586,  762,  774,  321,  778,  194,  779,  788,  362,
- 1391,  785,  787,  794,  806,   90,   91,   92,  807,  810,
-  321,  809,  813, 1403, 1405,   94,   43,  830,  716, 1260,
-  363,  364,  365,  366,  367,  368,  369,  370,  371,  372,
-  477,  825,  831,  832,  833,  840,  838,  837,  196,  854,
- 1391, 1391,  836,  858,  859,  861,  868, 1413,  194,  830,
-  870,  869,  883,  897,  892,  881,  899,  903,  906,  907,
-  913,  104,  485,  914,  194,  321,  321,  916,  917,  919,
-  922,  924,  930,  321,  586,  942,  943,  944,  945,  586,
-  716,  586,  586,  586,  586,  586,  586,  586,  586,  586,
-  586,  586,  951,  953,  321,  321, 1391,  321,  960,  495,
-  969,  967,  586,  975,  586,  971,  586,  973,  586,  586,
-  586,  979,  990,  980,  999, 1007,  716, 1006,  321,  194,
-  194,  321, 1013, 1014,  586, 1461, 1461,  194, 1015, 1019,
- 1022, 1020, 1469, 1469,  586,  586,  512,  575,  575, 1032,
-  865,  512,  512, 1038, 1037, 1040, 1045,  586,  194,  194,
- 1053,  194, 1057, 1060, 1061, 1062, 1063, 1281, 1070, 1075,
- 1082, 1084, 1104,  586,  512, 1079, 1096, 1091, 1102, 1135,
- 1281, 1100,  194, 1107,  512,  194, 1281,  512,  512, 1114,
- 1142, 1140,  512, 1281, 1138,  512, 1144,  512, 1124,  512,
-  512,  512,  512, 1151, 1156, 1143, 1160,  512, 1152, 1159,
- 1161,  512, 1162, 1208, 1164,  512, 1168, 1211, 1213, 1271,
- 1216, 1223, 1214,  512, 1284,  773,  512, 1241,  512,  512,
- 1239, 1262, 1287, 1288,  512, 1298,  512,  512,  512,  512,
-  512,  512,  512,  512,  512,  512,  512, 1301, 1304,  512,
- 1313, 1297, 1322, 1315, 1316, 1305,  512,  512, 1307,  512,
-  512,  512,  512,  512,  512,  512, 1318,  512,  512, 1319,
+  protected static readonly short [] yyTable = {           109,
+  156,   18,  110,  157,  508,  505,   44,  716,  190,  235,
+  721,  423,  193,  320,  325,  481,  667,  441,  422,  466,
+  258,  753,  314,  398,  544,  535,  501,  260,  689,  524,
+  489,  759,  981,  350, 1098,  561,  863,  763,  844,  845,
+  306,  161,  925,  162,  253,  461,  562,  694,  785,  355,
+  347,  363,  530,  354,  259,  362,  300, 1470,  783,  497,
+  300, 1131, 1132, 1336, 1028,  307,  405,  309, 1027,  405,
+  114,  854,  546, 1422,  163,  650,   14,  331,  231,   20,
+ 1028,  874,  191,  876,  750,  851, 1218,  259,  526,  326,
+  342,  259,  259,  259,  259,  259,  259,  259,  259,  660,
+ 1012,  651, 1225, 1014, 1296,  403,  164, 1157,  289,  638,
+ 1126,  760, 1237,  114,  858,    1,  290,  114,  807, 1445,
+   65,   65,  165, 1092,   65,  686,  430,  431,  850,  547,
+  466,  166,  620,  652,   16,  167,  168,  169,  344,   48,
+  109,  156, 1237,  110,  157,  751,  852,  235,  785,  406,
+  170,    2,  406,  761,  407,  675,  408,  407,  404,  408,
+  171,  345,  409,  410,  437,  409,  410,   45,   94,   48,
+  498,  695,  499,  198,  251,  346, 1179, 1471,  112,   49,
+ 1446,   48,  161,  784,  162,  344,  686,  471, 1337,  855,
+  262,  440, 1423, 1127,  286,  287,  288,  710,  292,  293,
+    6,  347,  785,  304,  305,  846,  441, 1366,  345,  714,
+  310,  114,  312,  479,  316,  163,  734,    2, 1029,  327,
+  328,  112,  233,  252,  533,  112,  500,   20,  859,  510,
+  438,  465,  860,  461, 1029,  544,  469,  653,   15,  411,
+  676,  361,  421,  347,  192,  544,  258,  164, 1309,  323,
+  323,  360,  523,  477,  258,  432,  528,   43,  291,  562,
+  532,  661, 1013,  165,  531, 1015, 1297,  787,  233,  323,
+  553,  480,  166, 1404,  484,  486,  167,  168,  169,  522,
+  259, 1393, 1435,    3,    4,    5,    6,  511,  259,  233,
+  941,  170,  519,   48,  521,  567,  520, 1024,  484,  925,
+ 1428,  171,  374,  549,  600,  601,  789,  939, 1050,  537,
+  538,   55, 1438,  543, 1439,  858,  545,  345,  233,  112,
+  233,  344,  925,  300,  628,  629,  201,  449,  662,  514,
+  808,  767,  623,  625, 1436, 1400,  630,  196,  630,  114,
+  562, 1310,  465,  578,  345,  202,  728,  586,  587,  588,
+  589,  590,  591,  592,  593,  594,  595,  596,  259,  379,
+ 1156,  734,  323,  323,  344,  114,  975,  643,  969, 1324,
+  259,  259,  259,  635,  687,  259,  259,  663, 1172,  618,
+  235,  664,  342,  114,  310,  450,  361,  345,  449, 1271,
+  639,  953, 1448,  630,  233,  380, 1354, 1355,  837, 1357,
+  879,  879,  663,  344,  630,  196,  196,  668,  347, 1456,
+ 1376,  662, 1104, 1383, 1384,  824,  374,  633,  374,  643,
+  374,  778,  825,  323,  502,  196,  345,  957, 1399, 1241,
+  344,  654,  347,  860,  925,  687,  518,  489,  233,  662,
+  925,  466,  665, 1134, 1135,  688,  450,  112,  461,  323,
+ 1137,  561,  263,  345, 1019, 1430, 1431,    6,  684,  323,
+  636,  637,  562,  462,  374,  323,  648,  346,  466, 1036,
+  466, 1037,  643,  112,  352,  381,  382,  643,  779, 1288,
+  879,  643,  712, 1289,  578,  663,  719,  878,  878,  246,
+   94,  112,  475, 1020,  251,  227,  643,  228,  247,  725,
+  727, 1198,  248,  313,  821,  461,  323,  360,  743,  323,
+  733, 1462,  768,  663,  770,  745,  771,  937,  196,  196,
+  462, 1038,  959,  643,  543,  466,  342,  545,  822,  562,
+  227,  114,  230,  968,  543,  755,  932,  545, 1199,  372,
+  323,  323,  643,  252, 1198,  476, 1229,  405,  342,  641,
+  251,  889,  249,  951,  710,  823,  773,  773,  669,  340,
+  259,  643, 1181, 1197, 1051, 1067,  643,  878,  323,  323,
+  643, 1200,  689,  641,  344,  856, 1229,  642,  800,  196,
+  669, 1199, 1181, 1230,  328,  643,  753,  344,  199,  964,
+  360, 1269, 1272,  294,  114,  295,  344,  345,  508,  252,
+  641,  642,  685,  786,  114,  196, 1197,  341, 1228,  792,
+  345,  346,  643, 1230, 1200,  196, 1231,  739,  360,  345,
+  199,  196,  360,  250,  360,  360,  360,  360,  642,  367,
+  406,  643,  360,  346,   48,  407,  342,  408, 1228,  112,
+ 1270, 1273,  726,  409,  410, 1201, 1231,  805, 1202,  347,
+  372,  866,  372,  465,  372,  372,  338,  372,  261,  372,
+  345,  258,  196,   94,  820,  196,  739,  484,  343,  326,
+  528,  344,  879,  714,  769,  367,  842,  351,  251,  323,
+  356,  719,  383,  384,  344,  883,  712, 1000, 1201,  806,
+ 1232, 1202, 1203, 1233,  345,  259,  196,  196, 1204,  357,
+  358,  372,  112,  372,  909,  338,  372,  345,  346,  909,
+ 1205,  909,  112,  867,  909,  909,  513,  909,  909,  359,
+ 1232,  346,  323, 1233,  196,  196,  877,  252,  878,  514,
+  360,  352,  331,  669,  568, 1203,  345, 1234,  331,  909,
+  881, 1204,  196, 1235,  569,  332,  515,  353,  345,  699,
+  114,  114,  345, 1205, 1072, 1236,  196,  940,  578,  344,
+  313,  669,  639,  578,  891,  345,  719, 1234,  932,  544,
+  669,  570,  352, 1235,  594,  345,  425,  907,  908,  389,
+  390,  571,  345,  352,  344, 1236,  344,  345,  427, 1101,
+  611,  345,  611,  114,  909,  114,  346,  345,  494,  870,
+  544,  313,  495,  323,  345,  654,  912,  345,  929,  345,
+  480,  912,  313,  912,  868,  635,  912,  912,  921,  912,
+  912, 1049,  484, 1000,  323,  955, 1133,  765, 1107,  765,
+  544,  765,  958,  555,  345,  735,  345, 1222,  667,  395,
+  556,  912,  966,  585,  719,   94,  345, 1004,  313,  345,
+  345,  396,  557,  427, 1261, 1387,  799,  594,  112,  112,
+  602,  603,  594,  345,  594,  594,  594,  594,  594,  594,
+  594,  594,  594,  594,  594,   94, 1292,  345,  196,  801,
+  345,  985, 1299,  987, 1311,  989,  594,  323,  594, 1305,
+  594,  802,  594,  594,  594,   94,  912, 1215,  441,  999,
+  903,  112,  345,  112, 1155,  903,  654,  903,  323,  868,
+  903,  903, 1115,  903,  903, 1061, 1258, 1440,  800,  338,
+  665,  323,  338, 1258, 1006,  323, 1007, 1062, 1008,  665,
+  719,  905,  980,  555,  781,  830,  905,  552,  905,  347,
+  556,  905,  905,  364,  905,  905,   25,  594,   26,  282,
+  391,   27,  557, 1459,  664,  508,   28,  392,  282,  196,
+   29,  670,  751,  664,  755,  671,  751,  702, 1042,   31,
+ 1044,  703, 1045, 1476, 1477,  291,   33,  291,  393,  711,
+  196,   34,  291,  495,  772,   35,  385,  386,  671,  394,
+  903,   66,  323,  323, 1052,   66, 1053,   37, 1054,   38,
+  387,  388,  754,   39,  754,  747,  754,  747,  397,  114,
+  480,   40,   41,  588,  945,   42,  945,  756,  317,  756,
+  400,  905, 1079,  719,  427,  181,  899,  181,   36,  181,
+ 1086,  899,  169,  899,  169,  999,  899,  899,  295,  899,
+  899,  428,  480,  196, 1091,  480,  429,  193,  235,  193,
+ 1118,  193,  406,  323,  376,  377,  378,  407,  543,  408,
+  176,  545,  176, 1111,  196,  409,  410,  345,  433,  932,
+ 1114,  177,  235,  177,  227,  345,  345,  196,  345,  345,
+   57,  196,  480,  323,  360,  589,  433, 1176,  360,  543,
+  345,  360,  545,  360, 1139, 1045,  588,  436,  360,  349,
+  462,  588, 1118,  588,  588,  588,  588,  588,  588,  588,
+  588,  588,  588,  588,  904,  905,  899,  112,  463,  543,
+ 1180, 1196,  545,  474,  114,  588,  470,  588,  114,  588,
+  196,  588,  588,  588,  482, 1168,  606,  607,  608,  609,
+ 1180,  856, 1176,  856,   68,  529,   68,  588,  196,  196,
+  199, 1213,  199,  480,  483,  114,  114,  588,  588,  114,
+  353,  170,  114,  170, 1196,  504, 1180,  135,  589,  135,
+  588, 1267, 1268,  589,  534,  589,  589,  589,  589,  589,
+  589,  589,  589,  589,  589,  589,  588,  509,  296,  114,
+  296,  142,  303,  142,  303, 1295, 1180,  589, 1298,  589,
+  512,  589,  548,  589,  589,  589, 1263, 1449, 1450,  196,
+  566,  332,  333,  334,  335,  336,  337,  338,  339,  589,
+  345,  507, 1303,  572,  345,  626,  345,  507,  349,  589,
+  589,  196,  112,  634,  350, 1303,  112,  649,  350,  196,
+  345,  130,  589,  130,  672,  345,  345,  674,  130, 1083,
+ 1084,  686, 1332,  696, 1333,  323,  531,  531,  589,  878,
+  878,  643,  643,  112,  112,  345,  697,  112, 1096, 1097,
+  112, 1312,  698,  345,  350,  741,  345,  700,  350,  701,
+  345,  350,  350,  350,  723,   36,  604,  605,  350,   36,
+  610,  611,  724,  739,  740,  742, 1367,  112,  744,  746,
+   36,  747,  748,  749,  754,   36,  762,  323,  764,   36,
+  765,  776,   36, 1394,  777,  781,  788,  512,  782,  797,
+  790,  809,  350,  323,   36,   36, 1406, 1408,  791,   36,
+   36,  719, 1263,  810,  813,   36,  812,   36,   36,   36,
+   36,  816,   43,  480,  833,   36,  828,  834,  835,   36,
+  836,   36,  841, 1394, 1394,  839,  840,  843,  198,  857,
+ 1416,   36,  861,   36,   36,  862,   36,  864,  871,  872,
+   36,  873,  884,  886,  900,  895,  902,  906,  323,  323,
+  909,  916,  910,  917,  919,  920,  323,  925,  922,  927,
+   36,  365,  945,  719,  933,  946,   36,   36,  947,  954,
+  508,  956,  948,  424,  963,  424,  508,  323,  323, 1394,
+  323,  196,  366,  367,  368,  369,  370,  371,  372,  373,
+  374,  375,  498,  978,  424,  424,  972,  970,  983,  719,
+  993,  323,  974,  592,  323,  976, 1002,  982, 1464, 1464,
+  536, 1009, 1010, 1016,  424, 1472, 1472, 1017, 1018, 1025,
+  578,  578,  424, 1022,  868,  424, 1023, 1035, 1040, 1041,
+ 1043, 1048, 1056,  196, 1060, 1064, 1065, 1063, 1066, 1073,
+ 1078, 1082, 1087, 1085, 1099, 1094, 1107, 1103,  536,  196,
+ 1117, 1105, 1110, 1138, 1141,  832, 1143, 1155, 1147, 1145,
+  597,  598,  599, 1146, 1127,  536,  536,  536,  536,  536,
+  536,  536,  536,  536,  536,  536,  536,  536,  536,  536,
+  536, 1154, 1159, 1162, 1163, 1171,  592, 1164, 1165, 1214,
+ 1167,  592, 1211,  592,  592,  592,  592,  592,  592,  592,
+  592,  592,  592,  592,  196,  196, 1216, 1219, 1217, 1226,
+ 1242, 1265,  196, 1274, 1244,  592, 1287,  592, 1290,  592,
+ 1291,  592,  592,  592, 1301, 1300, 1304, 1307, 1308, 1316,
+ 1310, 1318, 1319,  196,  196, 1321,  196,  592, 1322, 1323,
+ 1325, 1329, 1284,  512, 1327, 1330, 1335, 1340,  512,  512,
+ 1343, 1350, 1377, 1398, 1347, 1284, 1348,  196, 1358, 1359,
+  196, 1284, 1362, 1372, 1379, 1391, 1388, 1389, 1284, 1392,
+ 1401,  512, 1402, 1415, 1413, 1412,  592, 1420, 1418, 1417,
+ 1421,  512,  536, 1432,  512,  512, 1433, 1426, 1437,  512,
+ 1441, 1442,  512, 1451,  512, 1436,  512,  512,  512,  512,
+ 1435, 1457, 1458, 1478,  512, 1479, 1480,    9,  512,  941,
+  542,  612,  512,  830,   32,  502,  933,  732,  800,  503,
+  512,  461,  775,  512,  613,  512,  512,   30,  676,   22,
+  804,  512,  501,  512,  512,  512,  512,  512,  512,  512,
+  512,  512,  512,  512,   30,  527,  750,   31,  323,  512,
+  766,  758,   31,  779,  512,  512,  780,  512,  512,  512,
+  512,  512,  512,  512,  220,  512,  512,  805,  512,  512,
+  512,  512,  512,  512,  512,  512,  512,  512,   96,  512,
   512,  512,  512,  512,  512,  512,  512,  512,  512,  512,
- 1320,  512,  512,  512,  512,  512,  512,  512,  512,  512,
   512,  512,  512,  512,  512,  512,  512,  512,  512,  512,
-  512,  512,  512, 1324, 1326,  512, 1327,  512, 1332,  512,
- 1337, 1340,  512, 1344, 1347,  830,  830, 1345,  512, 1355,
- 1356, 1374, 1359,  830,  830,  830,  830,  830, 1369,  830,
-  830, 1376,  830,  830,  830,  830,  830,  830,  830,  830,
- 1385, 1386, 1388, 1389,  830, 1395,  830,  830,  830,  830,
-  830,  830, 1398,  345,  830, 1399, 1409, 1410,  830,  830,
- 1412,  830,  830,  830, 1417, 1415, 1418, 1414, 1423, 1429,
- 1430, 1434, 1438,  830, 1439,  830, 1448,  830,  830, 1433,
- 1432,  830, 1454,  830,  830,  830,  830,  830,  830,  830,
-  830,  830,  830,  830,  830, 1455,  830, 1475, 1476,  830,
-  830,    9, 1477,  830,  830,  939,  542,  828,  730,   32,
-  502,  931,  610,  798,  503,  461,  611,  674,   30,  830,
-  830,  830,   22,  802,  501,  830,  830,   30,  748,  830,
-  220,   31,  527,  323,  830,  830,  830,  830,  830,   96,
-   31,  756,  830,  803,  830,  836,  757,  748,  777,  805,
-  830,  830,  778,  807,  662,  662,  327,  684,  352,  345,
-  641,  138,  641,  230,   54,  234,  120,   21,  299,  145,
-  139,  121,  300,  146,  912,  830,  830,  830,  830,  991,
-  830,  773,  773, 1086, 1217, 1087, 1263,  830, 1431,  773,
-  773,  773,  773,  773, 1400,  773,  773, 1440,  773,  773,
-  773,  773,  773,  773,  773,  738, 1387, 1416, 1382, 1278,
-  773,  815,  773,  773,  773,  773,  773,  773,  939,  828,
-  773, 1290, 1471,  940,  773,  773,  941,  773,  773,  773,
- 1224, 1311, 1221,  935, 1464, 1406, 1411, 1404, 1463,  773,
- 1157,  773, 1331,  773,  773, 1282, 1158,  773,  908,  773,
-  773,  773,  773,  773,  773,  773,  773,  773,  773,  773,
-  773,  733,  773,  959,  846,  773,  773,  887,  772,  773,
-  773,  570,  885,  824,  295, 1023,  844,  609,  611,  610,
-  614,  882,  612, 1242,  613,  773,  773,  773, 1146, 1149,
- 1036,  773,  773, 1103,  396,  773, 1018, 1008, 1071, 1077,
-  773,  773,  773,  773,  773, 1073, 1066,  981,  773,  345,
-  773,  974,  726,  629,  345,  345,  773,  773, 1240, 1137,
-  910,    0,    0,    0,    0,    0,  909,    0,    0,    0,
-    0,    0,    0,    0,  338,    0,    0,  345,    0,    0,
-    0,  773,  773,  773,  773,    0,  773,  345,    0,    0,
-  345,  345,    0,  773,    0,  345,    0,    0,  345,    0,
-  345,    0,  345,  345,  345,  345,    0,    0,    0,    0,
-  345,    0,    0,    0,  345,    0,    0,    0,  345,    0,
-    0,    0,    0,    0,    0,    0,  345,    0,    0,  345,
-    0,  345,  345,    0,    0,    0,    0,  345,    0,  345,
-  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  345,    0,  345,    0,    0,    0,    0,    0,    0,  345,
+  512,  838,  759,  512,  750,  512,  807,  512,  664,  664,
+  512,  832,  832,  327,  686,  352,  512,  345,  138,  832,
+  832,  832,  832,  832,  643,  832,  832,  120,  832,  832,
+  832,  832,  832,  832,  832,  832,  299,  145,  139,  121,
+  832,  300,  832,  832,  832,  832,  832,  832,  146,  643,
+  832,  345,  232,   54,  832,  832,  236,  832,  832,  832,
+   21, 1089,  994, 1090,  915, 1220, 1266, 1434, 1403,  832,
+ 1443,  832, 1390,  832,  832, 1419, 1385,  832,  818,  832,
+  832,  832,  832,  832,  832,  832,  832,  832,  832,  832,
+  832,  942,  832,  943, 1281,  832,  832,  944, 1474,  832,
+  832,  831,  938, 1293, 1314, 1224, 1227, 1467, 1414, 1409,
+ 1407, 1466, 1160, 1334,  832,  832,  832,  911,  832, 1285,
+  736,  962,  832,  832,  573, 1161,  832,  849,  775,  297,
+  847,  832,  832,  832,  832,  832,  888,  329,  890,  832,
+  827,  832,  612, 1026,  613,  616,  614,  832,  832, 1149,
+  615,  885, 1152,  617, 1245, 1039,  399, 1106, 1080, 1021,
+ 1011,  984, 1074, 1076,  632, 1069,  729,  977, 1243, 1140,
+  913,  912,  832,  832,  832,  832,    0,  832,  775,  775,
+    0,    0,    0,    0,  832,    0,  775,  775,  775,  775,
+  775,    0,  775,  775,    0,  775,  775,  775,  775,  775,
+  775,  775,    0,    0,  740,    0,    0,  775,    0,  775,
+  775,  775,  775,  775,  775,    0,    0,  775,    0,    0,
+    0,  775,  775,    0,  775,  775,  775,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  775,    0,  775,  536,
+  775,  775,    0,    0,  775,    0,  775,  775,  775,  775,
+  775,  775,  775,  775,  775,  775,  775,  775,    0,  775,
+    0,    0,  775,  775,    0,    0,  775,  775,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,  775,  775,  775,    0,  775,    0,    0,    0,  775,
+  775,    0,    0,  775,    0,    0,    0,    0,  775,  775,
+  775,  775,  775,    0,    0,    0,  775,  345,  775,    0,
+    0,    0,  345,  345,  775,  775,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,  338,  345,    0,    0,    0,  775,
+  775,  775,  775,    0,  775,  345,    0,    0,  345,  345,
+    0,  775,    0,  345,    0,    0,  345,    0,  345,    0,
+  345,  345,  345,  345,    0,    0,    0,    0,  345,    0,
+    0,    0,  345,    0,    0,    0,  345,    0,    0,    0,
+    0,    0,    0,    0,  345,    0,    0,  345,    0,  345,
+  345,    0,    0,    0,    0,  345,    0,  345,  345,  345,
   345,  345,  345,  345,  345,  345,  345,  345,  345,    0,
-  345,  345,    0,    0,  345,  345,  345,  345,  345,    0,
-    0,  345,  345,    0,    0,    0,  345,  345,  345,  345,
-  345,  345,  345,  345,    0,    0,    0,    0,    0,    0,
-    0,  738,    0,  375,    0,  345,  738,  738,  345,    0,
-  345,    0,  345,    0,    0,  345,    0,    0,    0,    0,
-    0,  345,    0,    0,    0,    0,    0,    0,    0,  738,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  738,
-    0,    0,  738,  738,    0,    0,    0,  738,    0,    0,
-  738,    0,  738,    0,  738,  738,  738,  738,    0,    0,
-    0,    0,  738,    0,    0,    0,  738,    0,    0,    0,
-  738,    0,    0,    0,    0,    0,    0,    0,  738,    0,
-    0,  738,    0,  738,  738,    0,    0,    0,    0,  738,
-    0,  738,  738,  738,  738,  738,  738,  738,  738,  738,
-  738,  738,    0,    0,  738,    0,    0,    0,    0,    0,
-    0,  738,  738,  738,  738,  738,  738,    0,  738,  738,
-  738,    0,  738,  738,    0,    0,  738,  738,  738,  738,
-  338,    0,  345,  738,  738,  338,  338,    0,  738,  738,
-  738,  738,  738,  738,  738,  738,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  738,  338,    0,
-  738,    0,  738,    0,  738,    0,    0,  738,  338,    0,
-    0,  338,  338,  738,    0,    0,  338,    0,    0,  338,
+    0,    0,    0,  345,    0,    0,    0,    0,  345,  345,
+  345,  345,  345,  345,  345,  345,  345,  345,    0,  345,
+  345,    0,    0,  345,  345,  345,  345,  345,    0,    0,
+  345,  345,    0,    0,    0,  345,  345,  345,  345,  345,
+  345,  345,  345,    0,    0,    0,    0,    0,    0,    0,
+  740,    0,    0,    0,  345,  740,  740,  345,    0,  345,
+    0,  345,    0,    0,  345,    0,    0,    0,    0,    0,
+  345,  375,    0,    0,    0,    0,    0,    0,  740,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  740,    0,
+    0,  740,  740,    0,    0,    0,  740,    0,    0,  740,
+    0,  740,    0,  740,  740,  740,  740,    0,    0,    0,
+    0,  740,    0,    0,    0,  740,    0,    0,    0,  740,
+    0,    0,    0,    0,    0,    0,    0,  740,    0,    0,
+  740,    0,  740,  740,    0,    0,    0,    0,  740,    0,
+  740,  740,  740,  740,  740,  740,  740,  740,  740,  740,
+  740,    0,    0,    0,    0,    0,  740,    0,    0,    0,
+    0,  740,  740,  740,  740,  740,  740,    0,  740,  740,
+  740,    0,  740,  740,    0,    0,  740,  740,  740,  740,
+  338,    0,    0,  740,  740,  338,  338,    0,  740,  740,
+  740,  740,  740,  740,  740,  740,  345,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  740,  338,    0,
+  740,    0,  740,    0,  740,    0,    0,  740,  338,    0,
+    0,  338,  338,  740,    0,    0,  338,    0,    0,  338,
     0,  338,    0,  338,  338,  338,  338,    0,    0,    0,
     0,  338,    0,    0,    0,  338,    0,    0,    0,  338,
     0,    0,    0,    0,    0,    0,    0,  338,    0,    0,
   338,    0,  338,  338,    0,    0,    0,    0,  338,    0,
   338,  338,  338,  338,  338,  338,  338,  338,  338,  338,
-  338,    0,    0,  338,    0,    0,    0,    0,    0,    0,
-  338,  338,  338,  338,  338,  338,    0,  338,  338,  338,
-    0,  338,  338,    0,    0,  338,  338,  338,  338,  375,
-    0,    0,  338,  338,  375,  375,    0,  338,  338,  338,
-  338,  338,  338,  338,  338,    0,    0,  370,    0,    0,
-    0,    0,    0,    0,    0,    0,  338,  375,    0,  338,
-    0,  338,    0,  338,    0,    0,  338,  375,    0,    0,
-  375,  375,  338,    0,    0,  375,    0,    0,  375,    0,
-  375,    0,  375,  375,  375,  375,    0,    0,    0,    0,
-  375,    0,    0,    0,  375,    0,    0,    0,  375,    0,
-    0,    0,    0,    0,    0,    0,  375,    0,    0,  375,
-    0,  375,  375,    0,    0,    0,    0,  375,  201,  375,
-  375,  375,  375,  375,  375,  375,  375,  375,  375,  375,
-    0,    0,  375,    0,    0,    0,    0,    0,    0,  375,
-  375,    0,  375,  375,  375,    0,  375,  375,  375,    0,
-  375,  375,    0,    0,  375,  375,  375,  375,  345,    0,
-  202,  375,  375,    0,  345,    0,  375,  375,  375,  375,
-  375,  375,  375,  375,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  375,    0,    0,  375,    0,
-  375,    0,    0,    0,    0,    0,  345,    0,    0,    0,
-  345,  375,    0,    0,   49,    0,    0,    0,    0,  203,
-  204,  205,  206,    0,  207,  208,  209,  210,  211,  212,
-  213,  214,    0,    0,  215,  216,  217,  218,  219,  220,
-  221,  222,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  345,    0,    0,    0,    0,  345,    0,  345,  345,
+  338,    0,    0,    0,    0,    0,  338,    0,    0,    0,
+    0,  338,  338,  338,  338,  338,  338,    0,  338,  338,
+  338,    0,  338,  338,    0,    0,  338,  338,  338,  338,
+    0,    0,    0,  338,  338,    0,    0,    0,  338,  338,
+  338,  338,  338,  338,  338,  338,    0,  375,    0,    0,
+    0,    0,  375,  375,    0,    0,    0,  338,    0,    0,
+  338,    0,  338,  370,  338,    0,    0,  338,    0,    0,
+    0,    0,    0,  338,    0,  375,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  375,    0,    0,  375,  375,
+    0,    0,    0,  375,    0,    0,  375,    0,  375,    0,
+  375,  375,  375,  375,    0,    0,    0,    0,  375,    0,
+    0,    0,  375,    0,    0,    0,  375,    0,    0,    0,
+    0,    0,    0,    0,  375,    0,    0,  375,    0,  375,
+  375,    0,    0,    0,  915,  375,    0,  375,  375,  375,
+  375,  375,  375,  375,  375,  375,  375,  375,    0,    0,
+    0,    0,    0,  375,    0,    0,    0,    0,  375,  375,
+    0,  375,  375,  375,    0,  375,  375,  375,    0,  375,
+  375,    0,  345,  375,  375,  375,  375,    0,  345,    0,
+  375,  375,    0,    0,    0,  375,  375,  375,  375,  375,
+  375,  375,  375,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,  375,    0,    0,  375,    0,  375,
+  345,    0,    0,    0,  345,    0,    0,  915,    0,    0,
+  375,   49,  915,    0,  915,  915,  915,  915,  915,  915,
+  915,  915,  915,  915,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,  345,    0,    0,  915,    0,  915,    0,
+  915,    0,  915,  915,  915,  345,    0,    0,    0,    0,
+  345,    0,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  345,  345,    0,    0,    0,    0,    0,  345,
+    0,    0,    0,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  345,    0,  345,  345,    0,    0,  345,  345,
+  345,  345,  345,    0,    0,  345,  345,  915,    0,    0,
+  345,  345,  345,  345,  345,  345,  345,  345,    0,  370,
+    0,    0,    0,    0,    0,  370,    0,    0,    0,  345,
+    0,    0,  345,    0,  345,    0,  345,    0,    0,  345,
+   28,    0,    0,    0,    0,  345,    0,    0,    0,    0,
+    0,    0,  345,  345,  345,  345,    0,  370,    0,  345,
+  345,  370,    0,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,    0,  345,  345,  345,  345,  345,  345,  345,
   345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  592,    0,    0,    0,    0,    0,    0,    0,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,  345,    0,  345,
-  345,    0,    0,  345,  345,  345,  345,  345,    0,    0,
-  345,  345,    0,    0,    0,  345,  345,  345,  345,  345,
-  345,  345,  345,  370,    0,    0,    0,    0,    0,  370,
-    0,    0,    0,    0,  345,    0,   28,  345,    0,  345,
-    0,  345,    0,    0,  345,    0,    0,    0,    0,    0,
-  345,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  370,    0,  592,    0,  370,    0,    0,  592,    0,
-  592,  592,  592,  592,  592,  592,  592,  592,  592,  592,
-  592,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  592,    0,  592,    0,  592,    0,  592,  592,  592,
-    0,    0,    0,    0,   36,    0,  370,    0,    0,    0,
-    0,  370,    0,  370,  370,  370,  370,  370,  370,  370,
-  370,  370,  370,  370,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  370,  370,    0,  370,  370,  370,    0,
-  370,  370,  370,    0,  370,  370,    0,    0,  370,  370,
-  370,  370,  592,    0,    0,  370,  370,    0,    0,    0,
-  370,  370,  370,  370,  370,  370,  370,  370,    0,    0,
-    0,    0,    0,   35,    0,    0,    0,    0,    0,  370,
-    0,   49,  370,    0,  370,   49,    0,   49,    0,   49,
-    0,   49,    0,    0,   49,  370,   49,   49,    0,   49,
-    0,   49,    0,   49,    0,   49,   49,   49,   49,    0,
-    0,   49,   49,    0,    0,    0,   34,   49,   49,   49,
-   49,   49,    0,    0,   49,   49,   49,    0,   49,    0,
-   49,   49,   49,   49,   49,   49,   49,   49,    0,   49,
-   49,   49,   49,    0,    0,   49,   49,   49,    0,   49,
-    0,    0,    0,    0,   49,   49,    0,   49,   49,   28,
-   49,   49,   49,    0,    0,    0,   49,    0,    0,    0,
+  345,  345,  345,  345,  345,    0,    0,    0,    0,    0,
+    0,  345,  370,   35,  345,    0,    0,  370,    0,  370,
+  370,  370,  370,  370,  370,  370,  370,  370,  370,  370,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,   49,    0,    0,    0,   49,   49,    0,
-    0,    0,   28,   28,    0,    0,    0,   28,    0,    0,
-   49,   28,    0,   28,    0,    0,   28,    0,   28,   28,
-    0,   28,    0,   28,    0,   28,    0,   28,   28,   28,
-   28,    0,    0,   28,   28,    0,    0,    0,   33,   28,
-    0,   28,   28,   28,    0,    0,   28,   28,   28,    0,
-   28,   49,    0,   28,    0,   28,   28,   28,   28,    0,
-    0,    0,   28,   28,   28,    0,    0,   28,   28,   28,
-    0,   36,    0,    0,    0,   36,   28,   28,    0,   28,
-   28,  921,   28,   28,   28,    0,   36,    0,   28,    0,
-    0,   36,    0,    0,    0,   36,    0,    0,   36,    0,
-    0,    0,    0,    0,    0,   28,    0,    0,    0,    0,
-   36,   36,    0,   28,   28,   36,   36,    0,    0,    0,
-    0,   36,   28,   36,   36,   36,   36,    0,    0,    0,
-    0,   36,    0,    0,    0,   36,    0,   36,    0,    0,
-   35,    0,    0,    0,   35,    0,    0,   36,   48,   36,
-   36,    0,   36,    0,    0,   35,   36,    0,    0,    0,
-   35,    0,    0,   28,   35,    0,    0,   35,    0,    0,
-    0,    0,    0,   36,    0,    0,    0,    0,    0,   35,
-   35,   36,   36,   34,   35,   35,    0,   34,    0,    0,
-   35,    7,   35,   35,   35,   35,    0,    0,   34,    0,
-   35,    0,    0,   34,   35,    0,   35,   34,    0,    0,
-   34,    0,    0,    0,    0,    0,   35,    0,   35,   35,
-    0,   35,   34,   34,    0,   35,   28,   34,   34,    0,
-   28,    0,    0,   34,  922,   34,   34,   34,   34,    0,
-    0,   28,   35,   34,    0,    0,   28,   34,    0,   34,
-   28,   35,    0,   28,    0,    0,    0,    0,    0,   34,
-    0,    0,   34,    0,   34,   28,   28,    0,   34,    0,
-   28,   28,    0,    0,    0,    0,   28,    0,   28,   28,
-   28,   28,    0,    0,    0,   34,   28,    0,    0,    0,
-   28,    0,   28,   34,   34,   33,    0,    0,    0,   33,
-    0,    0,   28,    0,    0,   28,    0,   28,    0,    0,
-   33,   28,    0,    0,    0,   33,    0,    0,    0,   33,
-    0,    0,   33,    0,    0,    0,    0,    0,   28,    0,
-    0,    0,    0,    0,   33,   33,   28,   28,  921,   33,
-   33,    0,   48,    0,    0,   33,    0,   33,   33,   33,
-   33,    0,    0,   48,    0,   33,    0,    0,   48,   33,
-    0,   33,   48,    0,    0,   48,    0,    0,    0,    0,
-    0,   33,    0,    0,   33,    0,   33,   48,   48,    0,
-   33,    0,   48,   48,    0,    0,    0,    0,   48,    0,
-   48,   48,   48,   48,    0,    0,    0,   33,   48,    0,
-    0,    0,   48,    0,   48,   48,   33,    0,    0,   48,
-    0,    0,    0,    0,   48,    0,    0,   48,    0,   48,
-   48,    0,    0,   48,    0,   48,    0,    0,    0,   48,
-    0,    0,   48,    0,    0,    0,    0,    0,    0,    0,
-   48,    0,    0,    0,   48,   48,    0,    0,    7,   48,
-   48,    0,   49,    0,    0,   48,    0,   48,   48,   48,
-   48,    0,    0,   49,    0,   48,    0,    0,   49,   48,
-    0,   48,   49,    0,    0,   49,    0,    0,    0,    0,
-    0,   48,    0,    0,   48,    0,   48,   49,   49,    0,
-   48,  922,   49,   49,    0,   48,    0,    0,   49,    0,
-   49,   49,   49,   49,    0,    0,   48,   48,   49,    0,
-    0,   48,   49,    0,   49,   48,    0,    0,   48,    0,
-    0,    0,    0,    0,   49,    0,    0,   49,    0,   49,
-   48,   48,    0,   49,    0,   48,   48,    0,    0,    0,
-    0,   48,    0,   48,   48,   48,   48,    0,    0,    0,
-   49,   48,    0,    0,    0,   48,    0,   48,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,   48,    0,   56,
-   48,    0,   48,    0,    0,    0,   48,   57,   25,   58,
-   26,    0,    0,   27,   59,    0,   60,   61,   28,   62,
-   63,   64,   29,   48,    0,    0,    0,    0,   65,    0,
-   66,   31,   67,   68,   69,   70,    0,    0,   33,    0,
-    0,    0,   71,   34,    0,   72,   73,   35,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,   74,    0,   37,
-    0,   38,   75,    0,    0,   39,    0,   76,   77,   78,
-   79,   80,   81,   40,   41,   82,   83,   42,   84,    0,
-   85,    0,    0,   86,   87,  345,    0,   88,   89,    0,
-    0,  345,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,   90,   91,   92,    0,    0,    0,   93,
-    0,    0,    0,   94,    0,    0,    0,    0,   95,   96,
-   97,   98,   99,    0,    0,    0,  100,  345,  101,    0,
-    0,    0,    0,    0,  102,  103,    0,    0,    0,    0,
+  370,  370,    0,  370,  370,  370,    0,  370,  370,  370,
+    0,  370,  370,    0,    0,  370,  370,  370,  370,    0,
+   34,    0,  370,  370,    0,    0,    0,  370,  370,  370,
+  370,  370,  370,  370,  370,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  370,    0,   49,  370,
+    0,  370,   49,    0,   49,    0,   49,    0,   49,    0,
+    0,   49,  370,   49,   49,    0,   49,    0,   49,    0,
+   49,    0,   49,   49,   49,   49,    0,    0,   49,   49,
+    0,    0,    0,   28,   49,   49,   49,   49,   49,    0,
+    0,   49,   49,   49,    0,   49,    0,   49,   49,   49,
+   49,   49,   49,   49,   49,    0,   49,   49,   49,   49,
+    0,    0,   49,   49,   49,    0,   49,    0,    0,    0,
+    0,   49,   49,    0,   49,   49,   33,   49,   49,   49,
+    0,    0,    0,   49,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  345,    0,    0,    0,    0,    0,  345,    0,  104,
-  105,  106,  107,    0,    0,    0,    0,    0,  345,    0,
-    0,  196,    0,  345,    0,  345,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,    0,    0,    0,
-    0,    0,    0,  345,    0,    0,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,    0,  345,  345,    0,  345,
-  345,  345,  345,  345,  345,  345,  345,  345,  345,    0,
-  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
+    0,    0,    0,   49,    0,   49,   49,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   28,   28,   49,    5,
+    0,   28,    0,    0,    0,   28,    0,   28,    0,    0,
+   28,    0,   28,   28,    0,   28,    0,   28,    0,   28,
+    0,   28,   28,   28,   28,    0,    0,   28,   28,    0,
+    0,    0,    0,   28,    0,   28,   28,   28,    0,   49,
+   28,   28,   28,    0,   28,    0,    0,   28,    0,   28,
+   28,   28,   28,    0,    0,    0,   28,   28,   28,    0,
+   35,   28,   28,   28,   35,    0,  923,    0,    0,    0,
+   28,   28,    0,   28,   28,   35,   28,   28,   28,    0,
+   35,    0,   28,    0,   35,    0,    0,   35,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   35,
+   35,    0,   28,    0,   35,   35,    0,   34,   28,   28,
+   35,   34,   35,   35,   35,   35,    0,   28,    0,    0,
+   35,    0,   34,    0,   35,    0,   35,   34,    0,   48,
+    0,   34,    0,    0,   34,    0,   35,    0,   35,   35,
+    0,   35,    0,    0,    0,   35,   34,   34,    0,    0,
+    0,   34,   34,    0,    0,    0,    0,   34,   28,   34,
+   34,   34,   34,    0,    0,   35,    0,   34,    0,    0,
+   28,   34,   35,   34,   28,    0,    7,    0,    0,    0,
+    0,    0,    0,   34,    0,   28,   34,    0,   34,    0,
+   28,    0,   34,    0,   28,    0,    0,   28,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   28,
+   28,    0,   34,   33,   28,   28,    0,   33,   34,   34,
+   28,    0,   28,   28,   28,   28,    0,    0,   33,    0,
+   28,    0,    0,   33,   28,    0,   28,   33,    0,  924,
+   33,    0,    0,    0,    0,    0,   28,    0,    0,   28,
+    0,   28,   33,   33,    0,   28,    5,   33,   33,    0,
+   48,    0,    0,   33,    0,   33,   33,   33,   33,    0,
+    0,   48,    0,   33,    0,   28,   48,   33,    0,   33,
+   48,   28,   28,   48,    0,    0,    0,    0,    0,   33,
+    0,    0,   33,    0,   33,   48,   48,    0,   33,    0,
+   48,   48,    0,    0,    0,    0,   48,    0,   48,   48,
+   48,   48,    0,    0,    0,    0,   48,    0,   33,    0,
+   48,    0,   48,  923,    0,   33,    0,   48,    0,    0,
+    0,    0,   48,    0,    0,   48,    0,   48,   48,    0,
+    0,   48,    0,   48,    0,    0,    0,   48,    0,    0,
+   48,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   48,   48,   48,    0,    0,    0,   48,   48,    0,
+    0,    0,    0,   48,    0,   48,   48,   48,   48,    0,
+    0,    0,    0,   48,    0,    0,   48,   48,    0,   48,
+   48,    0,    0,    0,    0,    0,    0,    0,    0,   48,
+    0,   48,   48,    0,   48,    0,   48,    0,   48,    0,
+   48,    0,    0,   48,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   48,   48,    0,   48,    0,
+   48,   48,    0,    7,    0,    0,   48,   49,   48,   48,
+   48,   48,    0,    0,    0,    0,   48,    0,   49,    0,
+   48,    0,   48,   49,    0,    0,    0,   49,    0,    0,
+   49,    0,   48,    0,    0,   48,    0,   48,    0,    0,
+    0,   48,   49,   49,    0,    0,    0,   49,   49,    0,
+    0,    0,    0,   49,    0,   49,   49,   49,   49,    0,
+    0,   48,    0,   49,    0,    0,  924,   49,    0,   49,
+   48,    0,    0,    0,    0,    0,    0,    0,    0,   49,
+    0,   48,   49,    0,   49,    0,   48,    0,   49,    0,
+   48,    0,    0,   48,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   48,   48,    0,   49,    0,
+   48,   48,    0,    0,    0,    0,   48,    0,   48,   48,
+   48,   48,    0,    0,    0,    0,   48,    0,    0,    0,
+   48,    0,   48,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,   48,    0,   56,   48,    0,   48,    0,    0,
+    0,   48,   57,   25,   58,   26,    0,    0,   27,   59,
+    0,   60,   61,   28,   62,   63,   64,   29,    0,    0,
+    0,   48,    0,   65,    0,   66,   31,   67,   68,   69,
+   70,    0,    0,   33,    0,    0,    0,   71,   34,    0,
+   72,   73,   35,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,   74,    0,   37,    0,   38,   75,    0,    0,
+   39,    0,   76,   77,   78,   79,   80,   81,   40,   41,
+   82,   83,   42,   84,    0,   85,    0,    0,   86,   87,
+    0,  345,   88,   89,    0,    0,    0,  345,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   90,   91,   92,
+    0,   93,    0,    0,    0,   94,    0,    0,    0,   95,
+    0,    0,    0,    0,   96,   97,   98,   99,  100,    0,
+    0,    0,  101,  345,  102,    0,    0,    0,    0,    0,
+  103,  104,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  345,    0,    0,
+    0,    0,    0,  345,    0,  105,  106,  107,  108,    0,
+    0,    0,    0,    0,  345,    0,    0,  198,    0,  345,
+    0,  345,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  345,    0,    0,    0,    0,    0,    0,  345,
+    0,    0,    0,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,    0,  345,  345,    0,  345,  345,  345,  345,
+  345,  345,  345,  345,  345,  345,    0,  345,  345,  345,
   345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  345,  345,    0,  514,    0,    0,  345,    0,  345,  514,
-    0,  345,    0,    0,    0,    0,    0,  345,    0,    0,
-    0,    0,  345,    0,    0,  345,    0,  345,  345,    0,
-    0,    0,  345,  345,    0,    0,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,  514,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,  345,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  345,  345,    0,    0,
-    0,    0,    0,    0,  345,    0,    0,  345,    0,    0,
-    0,    0,    0,  345,    0,    0,  514,    0,    0,    0,
-    0,  514,    0,  514,  514,  514,  514,  514,  514,  514,
-  514,  514,  514,  514,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  514,  514,  514,  514,  514,  514,  514,
-  514,  514,  514,  913,  514,  514,    0,  514,  514,  514,
-  514,  514,  514,  514,  514,  514,  514,    0,  514,  514,
+  345,  345,  345,  345,  345,  345,  345,  345,  345,    0,
+  514,    0,    0,  345,    0,  345,  514,    0,  345,    0,
+    0,    0,    0,    0,  345,    0,    0,    0,    0,  345,
+    0,    0,  345,    0,  345,  345,    0,    0,    0,  345,
+  345,    0,    0,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  514,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  345,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,  345,  345,    0,    0,    0,    0,    0,
+    0,  345,  345,    0,  345,    0,    0,    0,    0,    0,
+  345,    0,    0,  514,    0,    0,    0,    0,  514,    0,
   514,  514,  514,  514,  514,  514,  514,  514,  514,  514,
+  514,    0,    0,    0,    0,    0,    0,    0,  345,    0,
+    0,  514,  514,  514,  514,  514,  514,  514,  514,  514,
+  514,    0,  514,  514,    0,  514,  514,  514,  514,  514,
+  514,  514,  514,  514,  514,    0,  514,  514,  514,  514,
   514,  514,  514,  514,  514,  514,  514,  514,  514,  514,
-    0,  510,    0,    0,    0,    0,  514,  510,    0,    0,
-    0,    0,    0,    0,    0,  514,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  510,    0,    0,  913,    0,    0,    0,
-    0,  913,    0,  913,  913,  913,  913,  913,  913,  913,
-  913,  913,  913,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  345,  913,    0,  913,    0,  913,    0,
-  913,  913,  913,    0,  510,    0,    0,    0,    0,  510,
-    0,  510,  510,  510,  510,  510,  510,  510,  510,  510,
-  510,  510,    0,    0,    0,    0,    0,    0,    0,  345,
-    0,  510,  510,    0,  510,  510,  510,  510,  510,  510,
-  510,    0,  510,  510,    0,  510,  510,  510,  510,  510,
-  510,  510,  510,  510,  510,  913,  510,  510,  510,  510,
-  510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
-  510,  510,  510,  510,  510,  510,  510,  510,    0,  518,
-    0,    0,    0,    0,  510,  518,    0,  510,  345,    0,
-    0,    0,    0,  510,    0,    0,    0,    0,    0,  345,
+  514,  514,  514,  514,  514,  514,  514,  514,    0,  510,
+    0,    0,    0,    0,  514,  510,    0,  345,    0,    0,
+    0,    0,    0,  514,    0,    0,    0,    0,    0,  345,
     0,  345,    0,  345,    0,    0,  345,    0,  345,  345,
     0,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  345,  518,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  510,  345,  345,  345,  345,  345,  345,  345,  345,
   345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
   345,  345,  345,  345,    0,    0,    0,    0,  345,    0,
   345,  402,    0,  345,    0,    0,    0,    0,    0,  345,
-    0,    0,  518,    0,    0,    0,    0,  518,    0,  518,
-  518,  518,  518,  518,  518,  518,  518,  518,  518,  518,
+    0,    0,  510,    0,    0,    0,    0,  510,    0,  510,
+  510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
     0,    0,    0,    0,    0,    0,    0,  402,    0,    0,
+  510,  510,    0,  510,  510,  510,  510,  510,  510,  510,
+    0,  510,  510,    0,  510,  510,  510,  510,  510,  510,
+  510,  510,  510,  510,    0,  510,  510,  510,  510,  510,
+  510,  510,  510,  510,  510,  510,  510,  510,  510,  510,
+  510,  510,  510,  510,  510,  510,  510,    0,  518,    0,
+    0,    0,    0,  510,  518,    0,  510,    0,    0,    0,
+    0,    0,  510,    0,    0,    0,    0,    0,  338,    0,
+  402,  402,  402,  402,    0,  402,    0,  402,  402,    0,
+  402,  402,  402,  402,  402,    0,  402,  402,  402,  402,
+  518,  402,  402,  402,  402,  402,  402,  402,  402,  402,
+  402,  402,  402,  402,  402,  402,  402,  402,  402,  402,
+  402,  402,  402,    0,    0,    0,    0,  338,    0,  402,
+  345,    0,  402,    0,    0,    0,    0,    0,  402,    0,
+    0,  518,    0,    0,    0,    0,  518,    0,  518,  518,
+  518,  518,  518,  518,  518,  518,  518,  518,  518,    0,
+    0,    0,    0,    0,    0,    0,  345,    0,    0,    0,
   518,    0,  518,  518,  518,  518,  518,  518,  518,    0,
   518,  518,    0,  518,  518,  518,  518,  518,  518,  518,
   518,  518,  518,    0,  518,  518,  518,  518,  518,  518,
   518,  518,  518,  518,  518,  518,  518,  518,  518,  518,
   518,  518,  518,  518,  518,  518,    0,  345,    0,    0,
     0,    0,  518,  345,    0,  518,    0,    0,    0,    0,
-    0,  518,    0,    0,    0,    0,    0,  338,    0,  402,
-  402,  402,  402,    0,  402,    0,  402,  402,    0,  402,
-  402,  402,  402,  402,    0,  402,  402,  402,  402,  345,
-  402,  402,  402,  402,  402,  402,  402,  402,  402,  402,
-  402,  402,  402,  402,  402,  402,  402,  402,  402,  402,
-  402,  402,    0,    0,    0,    0,  338,    0,  402,  345,
-    0,  402,    0,    0,    0,    0,    0,  402,    0,    0,
+    0,  518,    0,    0,    0,    0,    0,    0,  345,  345,
+  345,  345,  345,    0,    0,    0,  345,  345,    0,  345,
+  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,    0,    0,    0,    0,    0,    0,  345,    0,
+    0,  345,    0,    0,    0,    0,    0,  345,    0,    0,
   345,    0,    0,    0,    0,  345,    0,  345,  345,  345,
   345,  345,  345,  345,  345,  345,  345,  345,    0,    0,
-    0,    0,    0,    0,    0,  345,    0,    0,  345,    0,
-  345,  345,  345,  345,  345,  345,  345,    0,  345,  345,
-    0,  345,  345,  345,  345,  345,  345,  345,  345,  345,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,  345,
+    0,  345,  345,  345,  345,  345,  345,  345,    0,  345,
   345,    0,  345,  345,  345,  345,  345,  345,  345,  345,
+  345,  345,    0,  345,  345,  345,  345,  345,  345,  345,
   345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  345,  345,  345,  345,    0,  445,    0,    0,    0,    0,
-  345,  445,    0,  345,    0,    0,    0,    0,    0,  345,
-    0,    0,    0,    0,    0,    0,  345,  345,  345,  345,
-  345,    0,    0,    0,  345,  345,    0,  345,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,  445,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-    0,    0,    0,    0,    0,    0,  345,    0,    0,  345,
-    0,    0,    0,    0,    0,  345,    0,    0,  445,    0,
-    0,    0,    0,  445,    0,  445,  445,  445,  445,  445,
-  445,  445,  445,  445,  445,  445,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  445,    0,  445,  445,
-  445,  445,  445,  445,  445,    0,  445,  445,    0,  445,
-  445,  445,  445,  445,  445,  445,  445,  445,  445,    0,
-  445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
+  345,  345,  345,  345,  345,    0,  445,  730,    0,    0,
+    0,  345,  445,    0,  345,    0,   25,    0,   26,    0,
+  345,   27,    0,    0,    0,    0,   28,    0,    0,    0,
+   29,    0,    0,    0,    0,    0,    0,    0,    0,   31,
+    0,    0,    0,    0,    0,    0,   33,    0,  445,    0,
+    0,   34,    0,    0,    0,   35,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   37,    0,   38,
+    0,    0,    0,   39,    0,    0,    0,    0,    0,    0,
+    0,   40,   41,    0,    0,   42,    0,    0,  731,  445,
+    0,    0,    0,    0,  445,    0,  445,  445,  445,  445,
+  445,  445,  445,  445,  445,  445,  445,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  445,    0,
+  445,  445,  445,  445,  445,  445,  445,    0,  445,  445,
+    0,  445,  445,  445,  445,  445,  445,  445,  445,  445,
+  445,    0,  445,  445,  445,  445,  445,  445,  445,  445,
   445,  445,  445,  445,  445,  445,  445,  445,  445,  445,
-  445,  445,    0,  405,  549,    0,    0,    0,  445,  405,
-    0,  445,    0,   25,    0,   26,    0,  445,   27,    0,
-    0,    0,    0,   28,    0,    0,    0,   29,    0,    0,
-    0,    0,    0,    0,    0,    0,   31,    0,    0,    0,
-    0,    0,    0,   33,    0,  405,    0,    0,   34,    0,
-    0,    0,   35,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,   37,    0,   38,    0,    0,    0,
-   39,    0,    0,    0,    0,    0,    0,    0,   40,   41,
-    0,    0,   42,    0,    0,  315,  405,    0,    0,    0,
-    0,  405,    0,  405,  405,  405,  405,  405,  405,  405,
-  405,  405,  405,  405,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  405,    0,  405,  405,  405,  405,
-  405,  405,  405,    0,  405,    0,    0,  405,  405,  405,
-  405,  405,  405,  405,  405,  405,  405,    0,  405,  405,
+  445,  445,  445,  445,    0,  405,  865,    0,    0,  732,
+  445,  405,    0,  445,    0,   25,    0,   26,    0,  445,
+   27,    0,    0,    0,    0,   28,    0,    0,    0,   29,
+    0,    0,    0,    0,    0,    0,    0,    0,   31,    0,
+    0,    0,    0,    0,    0,   33,    0,  405,    0,    0,
+   34,    0,    0,    0,   35,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   37,    0,   38,    0,
+    0,    0,   39,    0,    0,    0,    0,    0,    0,    0,
+   40,   41,    0,    0,   42,    0,    0,  317,  405,    0,
+    0,    0,    0,  405,    0,  405,  405,  405,  405,  405,
+  405,  405,  405,  405,  405,  405,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  405,    0,  405,
+  405,  405,  405,  405,  405,  405,    0,  405,    0,    0,
   405,  405,  405,  405,  405,  405,  405,  405,  405,  405,
+    0,  405,  405,  405,  405,  405,  405,  405,  405,  405,
   405,  405,  405,  405,  405,  405,  405,  405,  405,  405,
-    0,  547,  727,    0,    0,  346,  405,  547,    0,  405,
-    0,   25,    0,   26,    0,  405,   27,    0,    0,    0,
-    0,   28,    0,    0,    0,   29,    0,    0,    0,    0,
-    0,    0,    0,    0,   31,    0,    0,    0,    0,    0,
-    0,   33,    0,  547,    0,    0,   34,    0,    0,    0,
-   35,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,   37,    0,   38,    0,    0,    0,   39,    0,
-    0,    0,    0,    0,    0,    0,   40,   41,    0,    0,
-   42,    0,    0,  728,  547,    0,  588,    0,    0,  547,
-    0,  547,  547,  547,  547,  547,  547,  547,  547,  547,
-  547,  547,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  547,    0,  547,    0,  547,    0,  547,  547,
-  547,    0,  547,  547,    0,  547,  547,  547,  547,  547,
-  547,  547,  547,  547,  547,    0,    0,    0,  547,  547,
+  405,  405,  405,    0,  547,    0,  487,    0,  349,  405,
+  547,    0,  405,    0,   57,   25,    0,   26,  405,    0,
+   27,  255,    0,    0,    0,   28,   62,   63,    0,   29,
+    0,    0,    0,    0,    0,   65,    0,    0,   31,    0,
+    0,    0,    0,    0,    0,   33,  547,    0,    0,    0,
+   34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   37,    0,   38,   75,
+    0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
+   40,   41,  256,    0,   42,    0,    0,  547,    0,    0,
+    0,    0,  547,    0,  547,  547,  547,  547,  547,  547,
+  547,  547,  547,  547,  547,    0,    0,    0,    0,   90,
+   91,   92,    0,    0,    0,    0,  547,    0,  547,    0,
+  547,   95,  547,  547,  547,    0,  547,  547,    0,  547,
+  547,  547,  547,  547,  547,  547,  547,  547,  547,  367,
+    0,    0,  547,  547,  547,  547,  547,  547,  547,  547,
   547,  547,  547,  547,  547,  547,  547,  547,  547,  547,
-  547,  547,  547,  547,  547,  547,  559,  547,    0,    0,
-    0,    0,  559,  729,    0,    0,   48,    0,    0,  588,
-    0,    0,    0,  547,  588,    0,  588,  588,  588,  588,
-  588,  588,  588,  588,  588,  588,  588,    0,    0,   48,
-    0,    0,    0,    0,    0,    0,    0,  588,  559,  588,
-    0,  588,   48,  588,  588,  588,    0,   48,    0,    0,
-    0,    0,   48,    0,   48,   48,   48,   48,    0,  588,
-   48,    0,   48,  563,    0,    0,   48,    0,    0,  563,
-  588,    0,    0,    0,    0,    0,    0,    0,   48,  559,
-    0,   48,  588,   48,  559,    0,  559,  559,  559,  559,
-  559,  559,  559,  559,  559,  559,  559,    0,  588,    0,
-    0,    0,    0,    0,   48,  563,    0,  559,    0,  559,
-    0,  559,  310,  559,  559,  559,    0,  559,  559,    0,
-    0,  559,  559,  559,  559,  559,  559,  559,  559,  559,
-    0,    0,    0,  559,  559,  559,  559,  559,  559,  559,
-  559,    0,    0,    0,    0,    0,  563,    0,    0,    0,
-    0,  563,  559,  563,  563,  563,  563,  563,  563,  563,
-  563,  563,  563,  563,    0,    0,  566,    0,  559,    0,
-    0,    0,  566,    0,  563,    0,  563,    0,  563,    0,
-  563,  563,  563,    0,  563,  563,    0,    0,  563,  563,
-  563,  563,    0,    0,    0,  563,  563,    0,    0,    0,
-  563,  563,  563,  563,  563,  563,  563,  563,  566,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  563,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  564,    0,  563,    0,    0,    0,  564,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  566,
-    0,    0,    0,    0,  566,    0,  566,  566,  566,  566,
-  566,  566,  566,  566,  566,  566,  566,    0,    0,    0,
-    0,    0,    0,    0,    0,  564,    0,  566,    0,  566,
-    0,  566,    0,  566,  566,  566,    0,  566,  566,    0,
-    0,  566,  566,  566,  566,    0,    0,    0,  566,  566,
-    0,    0,    0,  566,  566,  566,  566,  566,  566,  566,
-  566,    0,    0,    0,    0,    0,  564,    0,    0,    0,
-    0,  564,  566,  564,  564,  564,  564,  564,  564,  564,
-  564,  564,  564,  564,    0,    0,  565,    0,  566,    0,
-    0,    0,  565,    0,  564,    0,  564,    0,  564,    0,
-  564,  564,  564,    0,  564,  564,    0,    0,  564,  564,
-  564,  564,    0,    0,    0,  564,  564,    0,    0,    0,
-  564,  564,  564,  564,  564,  564,  564,  564,  565,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  564,
+  561,  547,  367,    0,    0,    0,  561,  105,  488,    0,
+    0,    0,    0,    0,    0,  367,    0,  547,    0,    0,
+  367,    0,    0,  244,    0,  367,    0,  367,  367,  367,
+  367,    0,    0,    0,    0,  367,    0,    0,    0,  367,
+    0,    0,  561,  367,    0,    0,    0,    0,    0,    0,
+    0,  367,    0,    0,  367,    0,  367,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  565,    0,
+    0,    0,    0,    0,  565,    0,    0,    0,    0,    0,
+  367,    0,    0,  561,    0,    0,    0,    0,  561,    0,
+  561,  561,  561,  561,  561,  561,  561,  561,  561,  561,
+  561,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+  565,    0,  561,    0,  561,    0,  561,    0,  561,  561,
+  561,    0,  561,  561,    0,    0,  561,  561,  561,  561,
+  561,  561,  561,  561,  561,    0,  367,    0,  561,  561,
+  561,  561,  561,  561,  561,  561,    0,    0,    0,    0,
+    0,  565,    0,    0,    0,    0,  565,  561,  565,  565,
+  565,  565,  565,  565,  565,  565,  565,  565,  565,    0,
+    0,    0,  568,  561,    0,    0,    0,    0,  568,    0,
+  565,    0,  565,    0,  565,    0,  565,  565,  565,    0,
+  565,  565,    0,    0,  565,  565,  565,  565,    0,    0,
+    0,  565,  565,    0,    0,    0,  565,  565,  565,  565,
+  565,  565,  565,  565,  568,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  565,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  569,    0,  564,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  565,
-    0,    0,    0,    0,  565,    0,  565,  565,  565,  565,
-  565,  565,  565,  565,  565,  565,  565,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  565,    0,  565,
-    0,  565,    0,  565,  565,  565,    0,  565,  565,    0,
-    0,  565,  565,  565,  565,    0,    0,    0,  565,  565,
-  570,    0,    0,  565,  565,  565,  565,  565,  565,  565,
-  565,    0,    0,    0,    0,    0,  569,    0,    0,    0,
-    0,  569,  565,  569,  569,  569,  569,  569,  569,  569,
-  569,  569,  569,  569,    0,    0,    0,    0,  565,    0,
-    0,    0,    0,    0,  569,    0,  569,    0,  569,    0,
-  569,  569,  569,    0,    0,    0,    0,    0,  569,  569,
-  569,  569,    0,    0,    0,  569,  569,  571,    0,    0,
-  569,  569,  569,  569,  569,  569,  569,  569,    0,    0,
-    0,    0,    0,  570,    0,    0,    0,    0,  570,  569,
-  570,  570,  570,  570,  570,  570,  570,  570,  570,  570,
-  570,    0,    0,    0,    0,  569,    0,    0,    0,    0,
-    0,  570,    0,  570,    0,  570,    0,  570,  570,  570,
-    0,    0,    0,    0,    0,  570,  570,  570,  570,    0,
-    0,    0,  570,  570,  572,    0,    0,  570,  570,  570,
-  570,  570,  570,  570,  570,    0,    0,    0,    0,    0,
-  571,    0,    0,    0,    0,  571,  570,  571,  571,  571,
+  566,  565,    0,    0,    0,    0,  566,    0,    0,    0,
+    0,    0,    0,    0,    0,  568,    0,    0,    0,    0,
+  568,    0,  568,  568,  568,  568,  568,  568,  568,  568,
+  568,  568,  568,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,  566,    0,  568,    0,  568,    0,  568,    0,
+  568,  568,  568,    0,  568,  568,    0,    0,  568,  568,
+  568,  568,    0,    0,    0,  568,  568,  203,    0,    0,
+  568,  568,  568,  568,  568,  568,  568,  568,    0,    0,
+    0,    0,    0,  566,    0,    0,    0,    0,  566,  568,
+  566,  566,  566,  566,  566,  566,  566,  566,  566,  566,
+  566,    0,    0,    0,  567,  568,    0,    0,    0,  204,
+  567,    0,  566,    0,  566,    0,  566,    0,  566,  566,
+  566,    0,  566,  566,    0,    0,  566,  566,  566,  566,
+    0,    0,    0,  566,  566,    0,    0,    0,  566,  566,
+  566,  566,  566,  566,  566,  566,  567,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  566,    0,  205,
+  206,  207,  208,    0,  209,  210,  211,  212,  213,  214,
+  215,  216,  571,  566,  217,  218,  219,  220,  221,  222,
+  223,  224,    0,    0,    0,    0,    0,  567,    0,    0,
+    0,    0,  567,    0,  567,  567,  567,  567,  567,  567,
+  567,  567,  567,  567,  567,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  567,    0,  567,    0,
+  567,    0,  567,  567,  567,    0,  567,  567,    0,    0,
+  567,  567,  567,  567,    0,    0,    0,  567,  567,    0,
+  572,    0,  567,  567,  567,  567,  567,  567,  567,  567,
+    0,    0,    0,    0,    0,  571,    0,    0,    0,    0,
+  571,  567,  571,  571,  571,  571,  571,  571,  571,  571,
+  571,  571,  571,    0,    0,    0,    0,  567,    0,    0,
+    0,    0,    0,    0,  571,    0,  571,    0,  571,    0,
+  571,  571,  571,    0,    0,    0,    0,    0,  571,  571,
+  571,  571,    0,    0,    0,  571,  571,    0,  573,    0,
   571,  571,  571,  571,  571,  571,  571,  571,    0,    0,
-    0,    0,  570,    0,    0,    0,    0,    0,  571,    0,
-  571,    0,  571,    0,  571,  571,  571,    0,    0,    0,
-    0,    0,  571,  571,  571,  571,    0,    0,    0,  571,
-  571,  573,    0,    0,  571,  571,  571,  571,  571,  571,
-  571,  571,    0,    0,    0,    0,    0,  572,    0,    0,
-    0,    0,  572,  571,  572,  572,  572,  572,  572,  572,
-  572,  572,  572,  572,  572,    0,    0,    0,    0,  571,
-    0,    0,    0,    0,    0,  572,    0,  572,    0,  572,
-    0,  572,  572,  572,    0,    0,    0,    0,    0,  572,
-  572,  572,  572,    0,    0,    0,  572,  572,  574,    0,
-    0,    0,    0,  572,  572,  572,  572,  572,  572,    0,
-    0,    0,    0,    0,  573,    0,    0,    0,    0,  573,
-  572,  573,  573,  573,  573,  573,  573,  573,  573,  573,
-  573,  573,    0,    0,    0,    0,  572,    0,    0,    0,
-    0,    0,  573,    0,  573,    0,  573,    0,  573,  573,
-  573,    0,    0,    0,    0,    0,  573,  573,  573,  573,
-    0,    0,    0,  573,  573,  575,    0,    0,    0,    0,
-  573,  573,  573,  573,  573,  573,    0,    0,    0,    0,
-    0,  574,    0,    0,    0,    0,  574,  573,  574,  574,
-  574,  574,  574,  574,  574,  574,  574,  574,  574,    0,
-    0,    0,    0,  573,    0,    0,    0,    0,    0,  574,
-    0,  574,    0,  574,    0,  574,  574,  574,    0,    0,
-    0,    0,    0,  574,  574,  574,  574,    0,    0,    0,
-  574,  574,  576,    0,    0,    0,    0,  574,  574,  574,
-  574,  574,  574,    0,    0,    0,    0,    0,  575,    0,
-    0,    0,    0,  575,  574,  575,  575,  575,  575,  575,
-  575,  575,  575,  575,  575,  575,    0,    0,    0,    0,
-  574,    0,    0,    0,    0,    0,  575,    0,  575,    0,
+    0,    0,    0,  572,    0,    0,    0,    0,  572,  571,
+  572,  572,  572,  572,  572,  572,  572,  572,  572,  572,
+  572,    0,    0,    0,    0,  571,    0,    0,    0,    0,
+    0,    0,  572,    0,  572,    0,  572,    0,  572,  572,
+  572,    0,    0,    0,    0,    0,  572,  572,  572,  572,
+    0,    0,    0,  572,  572,    0,  574,    0,  572,  572,
+  572,  572,  572,  572,  572,  572,    0,    0,    0,    0,
+    0,  573,    0,    0,    0,    0,  573,  572,  573,  573,
+  573,  573,  573,  573,  573,  573,  573,  573,  573,    0,
+    0,    0,    0,  572,    0,    0,    0,    0,    0,    0,
+  573,    0,  573,    0,  573,    0,  573,  573,  573,    0,
+    0,    0,    0,    0,  573,  573,  573,  573,    0,    0,
+    0,  573,  573,    0,  575,    0,  573,  573,  573,  573,
+  573,  573,  573,  573,    0,    0,    0,    0,    0,  574,
+    0,    0,    0,    0,  574,  573,  574,  574,  574,  574,
+  574,  574,  574,  574,  574,  574,  574,    0,    0,    0,
+    0,  573,    0,    0,    0,    0,    0,    0,  574,    0,
+  574,    0,  574,    0,  574,  574,  574,    0,    0,    0,
+    0,    0,  574,  574,  574,  574,    0,    0,    0,  574,
+  574,    0,  576,    0,    0,    0,  574,  574,  574,  574,
+  574,  574,    0,    0,    0,    0,    0,  575,    0,    0,
+    0,    0,  575,  574,  575,  575,  575,  575,  575,  575,
+  575,  575,  575,  575,  575,    0,    0,    0,    0,  574,
+    0,    0,    0,    0,    0,    0,  575,    0,  575,    0,
   575,    0,  575,  575,  575,    0,    0,    0,    0,    0,
-  575,  575,  575,  575,    0,    0,    0,  575,  575,  577,
-    0,    0,    0,    0,  575,  575,  575,  575,  575,  575,
+  575,  575,  575,  575,    0,    0,    0,  575,  575,    0,
+  577,    0,    0,    0,  575,  575,  575,  575,  575,  575,
     0,    0,    0,    0,    0,  576,    0,    0,    0,    0,
   576,  575,  576,  576,  576,  576,  576,  576,  576,  576,
   576,  576,  576,    0,    0,    0,    0,  575,    0,    0,
-    0,    0,    0,  576,    0,  576,    0,  576,    0,  576,
-  576,  576,    0,    0,    0,    0,    0,  576,  576,  576,
-  576,    0,    0,    0,  576,  576,  578,    0,    0,    0,
-    0,  576,  576,  576,  576,  576,  576,    0,    0,    0,
-    0,    0,  577,    0,    0,    0,    0,  577,  576,  577,
+    0,    0,    0,    0,  576,    0,  576,    0,  576,    0,
+  576,  576,  576,    0,    0,    0,    0,    0,  576,  576,
+  576,  576,    0,    0,    0,  576,  576,    0,  578,    0,
+    0,    0,  576,  576,  576,  576,  576,  576,    0,    0,
+    0,    0,    0,  577,    0,    0,    0,    0,  577,  576,
   577,  577,  577,  577,  577,  577,  577,  577,  577,  577,
-    0,    0,    0,    0,  576,    0,    0,    0,    0,    0,
-  577,    0,  577,    0,  577,    0,  577,  577,  577,    0,
-    0,    0,    0,    0,    0,    0,  577,  577,    0,    0,
-    0,  577,  577,  579,    0,    0,    0,    0,    0,    0,
-  577,  577,  577,  577,    0,    0,    0,    0,    0,  578,
-    0,    0,    0,    0,  578,  577,  578,  578,  578,  578,
-  578,  578,  578,  578,  578,  578,  578,    0,    0,    0,
-    0,  577,    0,    0,    0,    0,    0,  578,    0,  578,
-    0,  578,    0,  578,  578,  578,    0,    0,    0,    0,
-    0,    0,    0,  578,  578,    0,    0,    0,  578,  578,
-  580,    0,    0,    0,    0,    0,    0,  578,  578,  578,
-  578,    0,    0,    0,    0,    0,  579,    0,    0,    0,
-    0,  579,  578,  579,  579,  579,  579,  579,  579,  579,
-  579,  579,  579,  579,    0,    0,    0,    0,  578,    0,
-    0,    0,    0,    0,  579,    0,  579,    0,  579,    0,
-  579,  579,  579,    0,    0,    0,    0,    0,    0,    0,
-  579,  579,    0,    0,    0,  579,  579,  581,    0,    0,
-    0,    0,    0,    0,  579,  579,  579,  579,    0,    0,
-    0,    0,    0,  580,    0,    0,    0,    0,  580,  579,
-  580,  580,  580,  580,  580,  580,  580,  580,  580,  580,
-  580,    0,    0,    0,    0,  579,    0,    0,    0,    0,
-    0,  580,    0,  580,    0,  580,    0,  580,  580,  580,
-    0,    0,    0,    0,    0,    0,    0,  580,  580,    0,
-    0,    0,  580,  580,  582,    0,    0,    0,    0,    0,
-    0,    0,    0,  580,  580,    0,    0,    0,    0,    0,
-  581,    0,    0,    0,    0,  581,  580,  581,  581,  581,
-  581,  581,  581,  581,  581,  581,  581,  581,    0,    0,
-    0,    0,  580,    0,    0,    0,    0,    0,  581,    0,
-  581,    0,  581,    0,  581,  581,  581,    0,    0,    0,
-    0,    0,    0,    0,  581,  581,    0,    0,    0,  581,
-  581,  583,    0,    0,    0,    0,    0,    0,    0,    0,
-  581,  581,    0,    0,    0,    0,    0,  582,    0,    0,
-    0,    0,  582,  581,  582,  582,  582,  582,  582,  582,
-  582,  582,  582,  582,  582,    0,    0,    0,    0,  581,
-    0,    0,    0,    0,    0,  582,    0,  582,    0,  582,
-    0,  582,  582,  582,    0,    0,    0,    0,    0,    0,
-    0,    0,  582,    0,    0,    0,  582,  582,  584,    0,
-    0,    0,    0,    0,    0,    0,    0,  582,  582,    0,
-    0,    0,    0,    0,  583,    0,    0,    0,    0,  583,
-  582,  583,  583,  583,  583,  583,  583,  583,  583,  583,
-  583,  583,    0,    0,    0,    0,  582,    0,    0,    0,
-    0,    0,  583,    0,  583,    0,  583,    0,  583,  583,
-  583,    0,    0,    0,    0,    0,    0,    0,    0,  583,
-    0,    0,    0,  583,  583,  585,    0,    0,    0,    0,
-    0,    0,    0,    0,  583,  583,    0,    0,    0,    0,
-    0,  584,    0,    0,    0,    0,  584,  583,  584,  584,
-  584,  584,  584,  584,  584,  584,  584,  584,  584,    0,
-    0,    0,    0,  583,    0,    0,    0,    0,    0,  584,
-    0,  584,    0,  584,    0,  584,  584,  584,    0,    0,
-    0,    0,    0,    0,    0,    0,  584,    0,    0,    0,
-    0,  584,  587,    0,    0,    0,    0,    0,    0,    0,
-    0,  584,  584,    0,    0,    0,    0,    0,  585,    0,
-    0,    0,    0,  585,  584,  585,  585,  585,  585,  585,
-  585,  585,  585,  585,  585,  585,    0,    0,    0,    0,
-  584,    0,    0,    0,    0,    0,  585,    0,  585,    0,
+  577,    0,    0,    0,    0,  576,    0,    0,    0,    0,
+    0,    0,  577,    0,  577,    0,  577,    0,  577,  577,
+  577,    0,    0,    0,    0,    0,  577,  577,  577,  577,
+    0,    0,    0,  577,  577,    0,  579,    0,    0,    0,
+  577,  577,  577,  577,  577,  577,    0,    0,    0,    0,
+    0,  578,    0,    0,    0,    0,  578,  577,  578,  578,
+  578,  578,  578,  578,  578,  578,  578,  578,  578,    0,
+    0,    0,    0,  577,    0,    0,    0,    0,    0,    0,
+  578,    0,  578,    0,  578,    0,  578,  578,  578,    0,
+    0,    0,    0,    0,  578,  578,  578,  578,    0,    0,
+    0,  578,  578,    0,  580,    0,    0,    0,  578,  578,
+  578,  578,  578,  578,    0,    0,    0,    0,    0,  579,
+    0,    0,    0,    0,  579,  578,  579,  579,  579,  579,
+  579,  579,  579,  579,  579,  579,  579,    0,    0,    0,
+    0,  578,    0,    0,    0,    0,    0,    0,  579,    0,
+  579,    0,  579,    0,  579,  579,  579,    0,    0,    0,
+    0,    0,    0,    0,  579,  579,    0,    0,    0,  579,
+  579,    0,  581,    0,    0,    0,    0,    0,  579,  579,
+  579,  579,    0,    0,    0,    0,    0,  580,    0,    0,
+    0,    0,  580,  579,  580,  580,  580,  580,  580,  580,
+  580,  580,  580,  580,  580,    0,    0,    0,    0,  579,
+    0,    0,    0,    0,    0,    0,  580,    0,  580,    0,
+  580,    0,  580,  580,  580,    0,    0,    0,    0,    0,
+    0,    0,  580,  580,    0,    0,    0,  580,  580,    0,
+  582,    0,    0,    0,    0,    0,  580,  580,  580,  580,
+    0,    0,    0,    0,    0,  581,    0,    0,    0,    0,
+  581,  580,  581,  581,  581,  581,  581,  581,  581,  581,
+  581,  581,  581,    0,    0,    0,    0,  580,    0,    0,
+    0,    0,    0,    0,  581,    0,  581,    0,  581,    0,
+  581,  581,  581,    0,    0,    0,    0,    0,    0,    0,
+  581,  581,    0,    0,    0,  581,  581,    0,  583,    0,
+    0,    0,    0,    0,  581,  581,  581,  581,    0,    0,
+    0,    0,    0,  582,    0,    0,    0,    0,  582,  581,
+  582,  582,  582,  582,  582,  582,  582,  582,  582,  582,
+  582,    0,    0,    0,    0,  581,    0,    0,    0,    0,
+    0,    0,  582,    0,  582,    0,  582,    0,  582,  582,
+  582,    0,    0,    0,    0,    0,    0,    0,  582,  582,
+    0,    0,    0,  582,  582,    0,  584,    0,    0,    0,
+    0,    0,    0,    0,  582,  582,    0,    0,    0,    0,
+    0,  583,    0,    0,    0,    0,  583,  582,  583,  583,
+  583,  583,  583,  583,  583,  583,  583,  583,  583,    0,
+    0,    0,    0,  582,    0,    0,    0,    0,    0,    0,
+  583,    0,  583,    0,  583,    0,  583,  583,  583,    0,
+    0,    0,    0,    0,    0,    0,  583,  583,    0,    0,
+    0,  583,  583,    0,  585,    0,    0,    0,    0,    0,
+    0,    0,  583,  583,    0,    0,    0,    0,    0,  584,
+    0,    0,    0,    0,  584,  583,  584,  584,  584,  584,
+  584,  584,  584,  584,  584,  584,  584,    0,    0,    0,
+    0,  583,    0,    0,    0,    0,    0,    0,  584,    0,
+  584,    0,  584,    0,  584,  584,  584,    0,    0,    0,
+    0,    0,    0,    0,    0,  584,    0,    0,    0,  584,
+  584,    0,  586,    0,    0,    0,    0,    0,    0,    0,
+  584,  584,    0,    0,    0,    0,    0,  585,    0,    0,
+    0,    0,  585,  584,  585,  585,  585,  585,  585,  585,
+  585,  585,  585,  585,  585,    0,    0,    0,    0,  584,
+    0,    0,    0,    0,    0,    0,  585,    0,  585,    0,
   585,    0,  585,  585,  585,    0,    0,    0,    0,    0,
-    0,    0,    0,  585,    0,    0,    0,    0,  585,  589,
-    0,    0,    0,    0,    0,    0,    0,    0,  585,  585,
-    0,    0,    0,    0,    0,  587,    0,    0,    0,    0,
-  587,  585,  587,  587,  587,  587,  587,  587,  587,  587,
-  587,  587,  587,    0,    0,    0,    0,  585,    0,    0,
-    0,    0,    0,  587,    0,  587,    0,  587,    0,  587,
-  587,  587,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  587,  590,    0,    0,    0,
-    0,    0,    0,    0,    0,  587,  587,    0,    0,    0,
-    0,    0,  589,    0,    0,    0,    0,  589,  587,  589,
-  589,  589,  589,  589,  589,  589,  589,  589,  589,  589,
+    0,    0,    0,  585,    0,    0,    0,  585,  585,    0,
+  587,    0,    0,    0,    0,    0,    0,    0,  585,  585,
+    0,    0,    0,    0,    0,  586,    0,    0,    0,    0,
+  586,  585,  586,  586,  586,  586,  586,  586,  586,  586,
+  586,  586,  586,    0,    0,    0,    0,  585,    0,    0,
+    0,    0,    0,    0,  586,    0,  586,    0,  586,    0,
+  586,  586,  586,    0,    0,    0,    0,    0,    0,    0,
+    0,  586,    0,    0,    0,    0,  586,    0,  590,    0,
+    0,    0,    0,    0,    0,    0,  586,  586,    0,    0,
+    0,    0,    0,  587,    0,    0,    0,    0,  587,  586,
+  587,  587,  587,  587,  587,  587,  587,  587,  587,  587,
+  587,    0,    0,    0,    0,  586,    0,    0,    0,    0,
+    0,    0,  587,    0,  587,    0,  587,    0,  587,  587,
+  587,    0,    0,    0,  591,    0,    0,    0,    0,  587,
     0,    0,    0,    0,  587,    0,    0,    0,    0,    0,
-  589,    0,  589,    0,  589,    0,  589,  589,  589,    0,
+    0,    0,    0,    0,  587,  587,    0,    0,    0,    0,
+    0,  590,    0,    0,    0,    0,  590,  587,  590,  590,
+  590,  590,  590,  590,  590,  590,  590,  590,  590,    0,
+    0,    0,    0,  587,    0,    0,    0,    0,    0,    0,
+  590,    0,  590,    0,  590,    0,  590,  590,  590,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  589,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  589,    0,    0,    0,    0,    0,  590,
-    0,    0,    0,    0,  590,  589,  590,  590,  590,  590,
-  590,  590,  590,  590,  590,  590,  590,    0,    0,    0,
-    0,  589,    0,    0,    0,    0,    0,  590,    0,  590,
-    0,  590,    0,  590,  590,  590,   56,    0,    0,    0,
-    0,    0,    0,    0,   57,   25,   58,   26,    0,  590,
+    0,    0,  590,    0,    0,    0,    0,  591,    0,    0,
+    0,    0,  591,  590,  591,  591,  591,  591,  591,  591,
+  591,  591,  591,  591,  591,  590,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,  591,    0,  591,    0,
+  591,  590,  591,  591,  591,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   56,    0,  591,    0,
+    0,    0,    0,    0,   57,   25,   58,   26,    0,  591,
    27,   59,    0,   60,   61,   28,   62,   63,   64,   29,
-    0,    0,    0,    0,    0,   65,    0,   66,   31,   67,
-   68,   69,   70,    0,    0,   33,    0,    0,    0,   71,
-   34,    0,   72,   73,   35,    0,    0,    0,  590,    0,
+    0,  591,    0,    0,    0,   65,    0,   66,   31,   67,
+   68,   69,   70,    0,    0,   33,    0,  591,    0,   71,
+   34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
     0,    0,    0,    0,   74,    0,   37,    0,   38,   75,
     0,    0,   39,    0,   76,   77,   78,   79,   80,   81,
    40,   41,   82,   83,   42,   84,    0,   85,    0,    0,
    86,   87,    0,    0,   88,   89,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   90,
+   91,   92,    0,   93,    0,    0,    0,   94,    0,    0,
+    0,   95,    0,    0,    0,    0,   96,   97,   98,   99,
+  100,    0,    0,    0,  101,    0,  102,    0,    0,    0,
+    0,    0,  103,  104,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,   93,    0,    0,    0,
-   94,    0,    0,    0,    0,   95,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  264,    0,    0,    0,  104,  105,  106,  107,
-   57,   25,   58,   26,    0,    0,   27,   59,    0,   60,
-   61,   28,   62,   63,   64,   29,    0,    0,    0,    0,
-    0,   65,    0,   66,   31,   67,   68,   69,   70,    0,
-    0,   33,    0,    0,    0,   71,   34,    0,   72,   73,
-   35,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   74,    0,   37,    0,   38,   75,    0,    0,   39,    0,
-   76,   77,   78,   79,   80,   81,   40,   41,   82,   83,
-   42,   84,    0,   85,    0,    0,   86,   87,    0,    0,
-   88,   89,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,  266,    0,    0,    0,  105,  106,  107,
+  108,   57,   25,   58,   26,    0,    0,   27,   59,    0,
+   60,   61,   28,   62,   63,   64,   29,    0,    0,    0,
+    0,    0,   65,    0,   66,   31,   67,   68,   69,   70,
+    0,    0,   33,    0,    0,    0,   71,   34,    0,   72,
+   73,   35,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,   74,    0,   37,    0,   38,   75,    0,    0,   39,
+    0,   76,   77,   78,   79,   80,   81,   40,   41,   82,
+   83,   42,   84,    0,   85,    0,    0,   86,   87,    0,
+    0,   88,   89,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,   90,   91,   92,    0,
-    0,    0,   93,    0,    0,    0,   94,    0,    0,    0,
-    0,   95,   96,   97,   98,   99,    0,    0,    0,  100,
-    0,  101,    0,    0,    0,    0,    0,  102,  103,    0,
+   93,    0,    0,    0,   94,    0,    0,    0,   95,    0,
+    0,    0,    0,   96,   97,   98,   99,  100,    0,    0,
+    0,  101,    0,  102,    0,    0,    0,    0,    0,  103,
+  104,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  536,    0,
-    0,    0,  104,  105,  106,  107,   57,   25,   58,   26,
-    0,    0,   27,   59,    0,   60,   61,   28,   62,   63,
-   64,   29,    0,    0,    0,    0,    0,   65,    0,   66,
-   31,   67,   68,   69,   70,    0,    0,   33,    0,    0,
-    0,   71,   34,    0,   72,   73,   35,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   74,    0,   37,    0,
-   38,   75,    0,    0,   39,    0,   76,   77,   78,   79,
-   80,   81,   40,   41,   82,   83,   42,   84,    0,   85,
-    0,    0,   86,   87,    0,    0,   88,   89,    0,    0,
+  539,    0,    0,    0,  105,  106,  107,  108,   57,   25,
+   58,   26,    0,    0,   27,   59,    0,   60,   61,   28,
+   62,   63,   64,   29,    0,    0,    0,    0,    0,   65,
+    0,   66,   31,   67,   68,   69,   70,    0,    0,   33,
+    0,    0,    0,   71,   34,    0,   72,   73,   35,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,   74,    0,
+   37,    0,   38,   75,    0,    0,   39,    0,   76,   77,
+   78,   79,   80,   81,   40,   41,   82,   83,   42,   84,
+    0,   85,    0,    0,   86,   87,    0,    0,   88,   89,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,   90,   91,   92,    0,    0,    0,   93,    0,
-    0,    0,   94,    0,    0,    0,    0,   95,   96,   97,
-   98,   99,    0,    0,    0,  100,    0,  101,    0,    0,
-    0,    0,    0,  102,  103,    0,    0,    0,    0,    0,
+    0,    0,    0,   90,   91,   92,    0,   93,    0,    0,
+    0,   94,    0,    0,    0,   95,    0,    0,    0,    0,
+   96,   97,   98,   99,  100,    0,    0,    0,  101,    0,
+  102,    0,    0,    0,    0,    0,  103,  104,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  918,    0,    0,    0,  104,  105,
-  106,  107,  918,  918,  918,  918,    0,    0,  918,  918,
-    0,  918,  918,  918,  918,  918,  918,  918,    0,    0,
-    0,    0,    0,  918,    0,  918,  918,  918,  918,  918,
-  918,    0,    0,  918,    0,    0,    0,  918,  918,    0,
-  918,  918,  918,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  918,    0,  918,    0,  918,  918,    0,    0,
-  918,    0,  918,  918,  918,  918,  918,  918,  918,  918,
-  918,  918,  918,  918,    0,  918,    0,    0,  918,  918,
-    0,    0,  918,  918,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  918,  918,
-  918,    0,    0,    0,  918,    0,    0,    0,  918,    0,
-    0,    0,    0,  918,  918,  918,  918,  918,    0,    0,
-    0,  918,    0,  918,    0,    0,    0,    0,    0,  918,
-  918,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  920,    0,    0,
+    0,  105,  106,  107,  108,  920,  920,  920,  920,    0,
+    0,  920,  920,    0,  920,  920,  920,  920,  920,  920,
+  920,    0,    0,    0,    0,    0,  920,    0,  920,  920,
+  920,  920,  920,  920,    0,    0,  920,    0,    0,    0,
+  920,  920,    0,  920,  920,  920,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  920,    0,  920,    0,  920,
+  920,    0,    0,  920,    0,  920,  920,  920,  920,  920,
+  920,  920,  920,  920,  920,  920,  920,    0,  920,    0,
+    0,  920,  920,    0,    0,  920,  920,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  782,    0,    0,    0,  918,  918,  918,  918,  782,  782,
-  782,  782,    0,    0,  782,  782,    0,  782,  782,  782,
-  782,  782,  782,  782,    0,    0,    0,    0,    0,  782,
-    0,  782,  782,  782,  782,  782,  782,    0,    0,  782,
-    0,    0,    0,  782,  782,    0,  782,  782,  782,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  782,    0,
-  782,    0,  782,  782,    0,    0,  782,    0,  782,  782,
-  782,  782,  782,  782,  782,  782,  782,  782,  782,  782,
-    0,  782,    0,    0,  782,  782,    0,    0,  782,  782,
+  920,  920,  920,    0,  920,    0,    0,    0,  920,    0,
+    0,    0,  920,    0,    0,    0,    0,  920,  920,  920,
+  920,  920,    0,    0,    0,  920,    0,  920,    0,    0,
+    0,    0,    0,  920,  920,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  782,  782,  782,    0,    0,    0,
-  782,    0,    0,    0,  782,    0,    0,    0,    0,  782,
-  782,  782,  782,  782,    0,    0,    0,  782,    0,  782,
-    0,    0,    0,    0,    0,  782,  782,    0,    0,    0,
+    0,    0,    0,    0,  784,    0,    0,    0,  920,  920,
+  920,  920,  784,  784,  784,  784,    0,    0,  784,  784,
+    0,  784,  784,  784,  784,  784,  784,  784,    0,    0,
+    0,    0,    0,  784,    0,  784,  784,  784,  784,  784,
+  784,    0,    0,  784,    0,    0,    0,  784,  784,    0,
+  784,  784,  784,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,  784,    0,  784,    0,  784,  784,    0,    0,
+  784,    0,  784,  784,  784,  784,  784,  784,  784,  784,
+  784,  784,  784,  784,    0,  784,    0,    0,  784,  784,
+    0,    0,  784,  784,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  784,  784,  784,
+    0,  784,    0,    0,    0,  784,    0,    0,    0,  784,
+    0,    0,    0,    0,  784,  784,  784,  784,  784,    0,
+    0,    0,  784,    0,  784,    0,    0,    0,    0,    0,
+  784,  784,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,  714,    0,    0,    0,
-  782,  782,  782,  782,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,  862,    0,   28,   62,   63,    0,   29,
-    0,    0,   25,    0,   26,   65,    0,   27,   31,    0,
-    0,    0,   28,    0,    0,   33,   29,    0,    0,    0,
-   34,    0,   72,   73,   35,   31,    0,    0,    0,    0,
-    0,    0,   33,    0,    0,    0,   37,   34,   38,   75,
-    0,   35,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,   37,   42,   38,    0,    0,    0,   39,
-    0,   87,    0,    0,   88,   89,    0,   40,   41,    0,
-    0,   42,    0,    0,  315,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,  501,  715,    0,    0,
-   94,    0,    0,    0,    0,    0,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,    0,
+    0,  717,    0,    0,    0,  784,  784,  784,  784,   57,
+   25,    0,   26,    0,    0,   27,  255,    0, 1003,    0,
+   28,   62,   63,    0,   29,    0,    0,   25,    0,   26,
+   65,    0,   27,   31,    0,    0,    0,   28,    0,    0,
+   33,   29,    0,    0,    0,   34,    0,   72,   73,   35,
+   31,    0,    0,    0,    0,    0,    0,   33,    0,    0,
+    0,   37,   34,   38,   75,    0,   35,   39,    0,    0,
+   77,    0,   79,    0,   81,   40,   41,  256,   37,   42,
+   38,    0,    0,    0,   39,    0,   87,    0,    0,   88,
+   89,    0,   40,   41,    0,    0,   42,    0,    0,  317,
+    0,    0,    0,    0,   90,   91,   92,    0,   93,    0,
+    0,    0,  504,  718,    0,    0,   95,    0,    0,    0,
+    0,    0,   97,   98,   99,  100,    0,    0,    0,  101,
+    0,  102,    0,    0,    0,    0,    0,  103,  104,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  714,    0,    0,    0,  104,  297,  106,  107,
-   57,   25,    0,   26,    0,    0,   27,  253,    0, 1000,
-    0,   28,   62,   63,  346,   29,    0,    0,   25,    0,
-   26,   65,    0,   27,   31,    0,    0,    0,   28,    0,
-    0,   33,   29,    0,    0,    0,   34,    0,   72,   73,
-   35,   31,    0,    0,    0,    0,    0,    0,   33,    0,
-    0,    0,   37,   34,   38,   75,  889,   35,   39,    0,
-    0,   77,    0,   79,    0,   81,   40,   41,  254,   37,
-   42,   38,    0,    0,    0,   39,    0,   87,    0,    0,
-   88,   89,    0,   40,   41,    0,    0,   42,    0,    0,
-  315,    0,    0,    0,    0,    0,   90,   91,   92,    0,
-    0,    0,  501,    0,    0,    0,   94,    0,    0,    0,
-    0,    0,   96,   97,   98,   99,    0,    0,    0,  100,
-    0,  101,    0,    0,    0,    0,    0,  102,  103,    0,
-    0,    0,    0,    0,    0,   57,   25,    0,   26,    0,
-    0,   27,  253,    0,    0,    0,   28,   62,   63,    0,
-   29,    0,  104,  297,  106,  107,   65,    0,    0,   31,
-    0,    0,    0,    0,    0,    0,   33,    0,    0,    0,
-  346,   34,    0,   72,   73,   35,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,   37,    0,   38,
-   75,    0,    0,   39,    0,    0,   77,    0,   79,    0,
-   81,   40,   41,  254,    0,   42,    0,    0,    0,    0,
-    0,    0,   87,    0,    0,   88,   89,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   90,   91,   92,    0,    0,    0,  701,  958,    0,
-    0,   94,    0,    0,    0,    0,    0,   96,   97,   98,
-   99,    0,    0,    0,  100,    0,  101,    0,    0,    0,
-    0,    0,  102,  103,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  684,    0,  104,  702,  106,
-  107,    0,    0,   57,   25,    0,   26,    0,  703,   27,
-  253,    0, 1119,    0,   28,   62,   63,    0,   29,    0,
-    0,   25,    0,   26,   65,    0,   27,   31,    0,    0,
-    0,   28,    0,    0,   33,   29,    0,    0,    0,   34,
-    0,   72,   73,   35,   31,    0,    0,    0,    0,    0,
-    0,   33,    0,    0,    0,   37,   34,   38,   75,    0,
-   35,   39,    0,    0,   77,    0,   79,    0,   81,   40,
-   41,  254,   37,   42,   38,    0,   85,    0,   39,    0,
-   87,    0,    0,   88,   89,    0,   40,   41,    0,    0,
-   42,    0,    0,  315,    0,    0,    0,    0,    0,   90,
-   91,   92,    0,    0,    0,    0,    0,    0,    0,   94,
-    0,    0,    0,    0,    0,   96,   97,   98,   99,    0,
-    0,    0,  100,    0,  101,    0,    0,    0,    0,    0,
-  102,  103,    0,    0,    0,    0,    0,    0,   57,   25,
-    0,   26,    0,    0,   27,  253,    0,    0,    0,   28,
-   62,   63,    0,   29,    0,  104,  297,  106,  107,   65,
-    0,    0,   31,    0,    0,    0,    0,    0,    0,   33,
-    0,    0,    0,  346,   34,    0,   72,   73,   35,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  717,    0,
+    0,    0,  105,  299,  107,  108,   57,   25,    0,   26,
+    0,    0,   27,  255,    0, 1122,    0,   28,   62,   63,
+  349,   29,    0,    0,   25,    0,   26,   65,    0,   27,
+   31,    0,    0,    0,   28,    0,    0,   33,   29,    0,
+    0,    0,   34,    0,   72,   73,   35,   31,    0,    0,
+    0,    0,    0,    0,   33,    0,    0,    0,   37,   34,
+   38,   75,  892,   35,   39,    0,    0,   77,    0,   79,
+    0,   81,   40,   41,  256,   37,   42,   38,    0,    0,
+    0,   39,    0,   87,    0,    0,   88,   89,    0,   40,
+   41,    0,    0,   42,    0,    0,  317,    0,    0,    0,
+    0,   90,   91,   92,    0,   93,    0,    0,    0,  504,
+    0,    0,    0,   95,    0,    0,    0,    0,    0,   97,
+   98,   99,  100,    0,    0,    0,  101,    0,  102,    0,
+    0,    0,    0,    0,  103,  104,    0,    0,    0,    0,
+    0,    0,   57,   25,    0,   26,    0,    0,   27,  255,
+    0,    0,    0,   28,   62,   63,    0,   29,    0,  105,
+  299,  107,  108,   65,    0,    0,   31,    0,    0,    0,
+    0,    0,    0,   33,    0,    0,    0,  349,   34,    0,
+   72,   73,   35,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,   37,    0,   38,   75,    0,    0,
+   39,    0,    0,   77,    0,   79,    0,   81,   40,   41,
+  256,    0,   42,    0,    0,    0,    0,    0,    0,   87,
+    0,    0,   88,   89,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   90,   91,   92,
+    0,   93,    0,    0,    0,  704,  961,    0,    0,   95,
+    0,    0,    0,    0,    0,   97,   98,   99,  100,    0,
+    0,    0,  101,    0,  102,    0,    0,    0,    0,    0,
+  103,  104,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   37,    0,   38,   75,    0,    0,   39,    0,    0,   77,
-    0,   79,    0,   81,   40,   41,  254,    0,   42,    0,
-    0,    0,    0,    0,    0,   87,    0,    0,   88,   89,
+    0,    0,    0,  687,    0,  105,  705,  107,  108,    0,
+    0,   57,   25,    0,   26,    0,  706,   27,  255,    0,
+    0,    0,   28,   62,   63,    0,   29,    0,    0,  186,
+    0,  186,   65,    0,  186,   31,    0,    0,    0,  186,
+    0,    0,   33,  186,    0,    0,    0,   34,    0,   72,
+   73,   35,  186,    0,    0,    0,    0,    0,    0,  186,
+    0,    0,    0,   37,  186,   38,   75,    0,  186,   39,
+    0,    0,   77,    0,   79,    0,   81,   40,   41,  256,
+  186,   42,  186,    0,   85,    0,  186,    0,   87,    0,
+    0,   88,   89,    0,  186,  186,    0,    0,  186,    0,
+    0,  186,    0,    0,    0,    0,   90,   91,   92,    0,
+   93,    0,    0,    0,    0,    0,    0,    0,   95,    0,
+    0,    0,    0,    0,   97,   98,   99,  100,    0,    0,
+    0,  101,    0,  102,    0,    0,  944,    0,    0,  103,
+  104,    0,    0,    0,    0,    0,    0,   57,   25,    0,
+   26,    0,    0,   27,  255,    0,    0,    0,   28,   62,
+   63,    0,   29,    0,  105,  299,  107,  108,   65,    0,
+    0,   31,    0,    0,    0,    0,    0,    0,   33,    0,
+    0,    0,  186,   34,    0,   72,   73,   35,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   37,
+    0,   38,   75,    0,    0,   39,    0,    0,   77,    0,
+   79,    0,   81,   40,   41,  256,    0,   42,    0,    0,
+    0,    0,    0,    0,   87,    0,    0,   88,   89,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,   90,   91,   92,    0,    0,    0,
-  701,    0,    0,    0,   94,    0,    0,    0,    0,    0,
-   96,   97,   98,   99,    0,    0,    0,  100,    0,  101,
-    0,    0,    0,    0,    0,  102,  103,    0,    0,    0,
+    0,    0,   90,   91,   92,    0,   93,    0,    0,    0,
+  704,    0,    0,    0,   95,    0,    0,    0,    0,    0,
+   97,   98,   99,  100,    0,    0,    0,  101,    0,  102,
+    0,    0,    0,    0,    0,  103,  104,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,  714,    0,
-  104,  702,  106,  107,    0,    0,   57,   25,    0,   26,
-    0,  703,   27,  253,    0,    0,    0,   28,   62,   63,
+    0,    0,    0,    0,    0,    0,    0,    0,  717,    0,
+  105,  705,  107,  108,    0,    0,   57,   25,    0,   26,
+    0,  706,   27,  255,    0,    0,    0,   28,   62,   63,
     0,   29,    0,    0,  186,    0,  186,   65,    0,  186,
    31,    0,    0,    0,  186,    0,    0,   33,  186,    0,
     0,    0,   34,    0,   72,   73,   35,  186,    0,    0,
     0,    0,    0,    0,  186,    0,    0,    0,   37,  186,
    38,   75,    0,  186,   39,    0,    0,   77,    0,   79,
-    0,   81,   40,   41,  254,  186,   42,  186,    0,    0,
+    0,   81,   40,   41,  256,  186,   42,  186,    0,    0,
     0,  186,    0,   87,    0,    0,   88,   89,    0,  186,
   186,    0,    0,  186,    0,    0,  186,    0,    0,    0,
-    0,    0,   90,   91,   92,    0,    0,    0,  501,    0,
-    0,    0,   94,    0,    0,    0,    0,    0,   96,   97,
-   98,   99,    0,    0,    0,  100,    0,  101,    0,    0,
-  942,    0,    0,  102,  103,    0,    0,    0,    0,    0,
+    0,   90,   91,   92,    0,   93,    0,    0,    0,  504,
+    0,    0,    0,   95,    0,    0,    0,    0,    0,   97,
+   98,   99,  100,    0,    0,    0,  101,    0,  102,  944,
+    0,    0,    0,    0,  103,  104,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  877,    0,    0,    0,  104,  297,
-  106,  107,   57,   25,    0,   26,    0,    0,   27,  253,
-    0,    0,    0,   28,   62,   63,  186,   29,    0,    0,
-  186,    0,  186,   65,    0,  186,   31,    0,    0,    0,
-  186,    0,    0,   33,  186,    0,    0,    0,   34,    0,
-   72,   73,   35,  186,    0,    0,    0,    0,    0,    0,
-  186,    0,    0,    0,   37,  186,   38,   75,    0,  186,
-   39,    0,    0,   77,    0,   79,    0,   81,   40,   41,
-  254,  186,   42,  186,    0,    0,    0,  186,    0,   87,
-    0,    0,   88,   89,    0,  186,  186,    0,    0,  186,
-    0,    0,  186,    0,    0,    0,    0,    0,   90,   91,
-   92,    0,    0,    0,    0,    0,    0,    0,   94,    0,
-    0,    0,    0,    0,   96,   97,   98,   99,    0,    0,
-    0,  100,    0,  101,  942,    0,    0,    0,    0,  102,
-  103,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  880,    0,    0,    0,  105,
+  299,  107,  108,   57,   25,    0,   26,    0,    0,   27,
+  255,    0,    0,    0,   28,   62,   63,  186,   29,    0,
+    0,   25,    0,   26,   65,    0,   27,   31,    0,    0,
+    0,   28,    0,    0,   33,   29,    0,    0,    0,   34,
+    0,   72,   73,   35,   31,    0,    0,    0,    0,    0,
+    0,   33,    0,    0,    0,   37,   34,   38,   75,    0,
+   35,   39,    0,    0,   77,    0,   79,    0,   81,   40,
+   41,  256,   37,   42,   38,    0,    0,    0,   39,    0,
+   87,    0,    0,   88,   89,    0,   40,   41,    0,    0,
+   42,    0,    0,  317,    0,    0,    0,    0,   90,   91,
+   92,    0,   93,    0,    0,    0,    0,    0,    0,    0,
+   95,    0,    0,    0,    0,    0,   97,   98,   99,  100,
+    0,    0,    0,  101,    0,  102,    0,    0,    0,    0,
+    0,  103,  104,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  614,    0,    0,    0,  104,  297,  106,  107,  614,  614,
-    0,  614,    0,    0,  614,  614,    0,    0,    0,  614,
-  614,  614,  186,  614,    0,    0,    0,    0,    0,  614,
-    0,    0,  614,    0,    0,    0,    0,    0,    0,  614,
-    0,    0,    0,    0,  614,    0,  614,  614,  614,    0,
-    0,    0,    0,    0,    0,    0,  345,    0,    0,    0,
-  614,    0,  614,  614,    0,    0,  614,    0,    0,  614,
-    0,  614,    0,  614,  614,  614,  614,    0,  614,    0,
-    0,    0,    0,    0,    0,  614,    0,    0,  614,  614,
-    0,    0,  345,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,  614,  614,  614,    0,    0,    0,
-    0,    0,    0,    0,  614,    0,    0,    0,    0,    0,
-  614,  614,  614,  614,    0,    0,    0,  614,    0,  614,
-    0,    0,    0,    0,    0,  614,  614,    0,    0,    0,
+    0,    0,  616,    0,    0,    0,  105,  299,  107,  108,
+  616,  616,    0,  616,    0,    0,  616,  616,    0,    0,
+    0,  616,  616,  616,  318,  616,    0,    0,    0,    0,
+    0,  616,    0,    0,  616,    0,    0,    0,    0,    0,
+    0,  616,    0,    0,    0,    0,  616,    0,  616,  616,
+  616,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,  616,    0,  616,  616,    0,    0,  616,    0,
+    0,  616,    0,  616,    0,  616,  616,  616,  616,    0,
+  616,    0,    0,    0,    0,    0,    0,  616,    0,    0,
+  616,  616,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  616,  616,  616,    0,  616,
+    0,    0,    0,    0,    0,    0,    0,  616,    0,    0,
+    0,    0,    0,  616,  616,  616,  616,    0,    0,    0,
+  616,    0,  616,    0,    0,    0,    0,    0,  616,  616,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-  614,  614,  614,  614,  345,  345,  345,  345,    0,    0,
-    0,  345,  345,    0,    0,  345,  345,  345,  345,  345,
-  345,  345,  345,  345,    0,  345,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,  345,  345,  345,
-  345,  345,  345,  345,  345,  345,  345,    0,   48,    0,
-    0,    0,   48,  345,   48,    0,  345,   48,    0,   48,
-   48,    0,   48,    0,   48,    0,   48,    0,   48,   48,
-   48,   48,    0,    0,   48,   48,    0,    0,    0,    0,
-   48,    0,   48,   48,   48,    0,    0,   48,    0,   48,
-    0,   48,    0,    0,   48,    0,   48,   48,   48,   48,
-    0,    0,    0,   48,   48,   48,    0,    0,   48,   48,
-   48,    0,    0,    0,    0,    0,    0,   48,   48,    0,
-   48,   48,    0,   48,   48,   48,    0,    0,    0,   48,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,   48,
-    0,    0,    0,   48,    0,   48,   48,    0,   48,    0,
-   48,   48,    0,   48,   81,   48,    0,   48,    0,   48,
-   48,   48,   48,   48,    0,   48,   48,    0,    0,    0,
-    0,   48,    0,   48,   48,   48,    0,    0,   48,    0,
-   48,    0,   48,    0,    0,   48,    0,   48,   48,   48,
-   48,    0,    0,    0,   48,   48,   48,    0,    0,   48,
-   48,   48,    0,    0,   48,    0,    0,    0,   48,   48,
-    0,   48,   48,    0,   48,   48,   48,    0,    0,    0,
-   48,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   48,    0,    0,    0,   48,    0,   48,   48,    0,   48,
-    0,   48,   48,    0,   48,   82,   48,    0,   48,    0,
-   48,   48,   48,   48,   48,    0,   48,   48,    0,    0,
-    0,    0,   48,    0,   48,   48,   48,    0,    0,   48,
+    0,    0,    0,  616,  616,  616,  616,   48,    0,    0,
     0,   48,    0,   48,    0,    0,   48,    0,   48,   48,
-   48,   48,    0,    0,    0,   48,   48,   48,    0,    0,
-   48,   48,   48,    0,    0,   48,    0,    0,    0,   48,
-   48,    0,   48,   48,    0,   48,   48,   48,    0,    0,
-    0,   48,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   48,    0,    0,    0,   48,    0,   48,   48,    0,
-   48,    0,   48,   48,    0,   48,  104,   48,    0,   48,
-    0,   48,   48,   48,   48,   48,    0,   48,   48,    0,
-    0,    0,    0,   48,    0,   48,   48,   48,    0,    0,
-   48,    0,   48,    0,   48,    0,    0,   48,    0,   48,
-   48,   48,   48,    0,    0,    0,   48,   48,   48,    0,
-    0,   48,   48,   48,    0,    0,   48,    0,    0,    0,
-   48,   48,    0,   48,   48,    0,   48,   48,   48,    0,
-    0,    0,   48,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,   48,    0,    0,    0,   48,    0,   48,   48,
-    0,   48,    0,   48,   48,    0,   48,  105,   48,    0,
-   48,    0,   48,   48,   48,   48,   48,    0,   48,   48,
-    0,    0,    0,    0,   48,    0,   48,   48,   48,    0,
-    0,   48,    0,   48,    0,   48,    0,    0,   48,    0,
-   48,   48,   48,   48,    0,    0,    0,   48,   48,   48,
-    0,    0,   48,   48,   48,    0,    0,   48,    0,    0,
-    0,   48,   48,    0,   48,   48,    0,   48,   48,   48,
-    0,    0,    0,   48,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,   48,    0,    0,    0,   48,    0,   48,
-   48,    0,   48,    0,   48,   48,    0,   48,  226,   48,
-    0,   48,    0,   48,   48,   48,   48,    0,    0,   48,
-   48,    0,    0,    0,    0,   48,    0,   48,   48,   48,
-    0,    0,   48,    0,   48,    0,   48,  345,    0,   48,
-    0,   48,   48,   48,   48,    0,    0,    0,   48,   48,
-   48,    0,    0,   48,   48,   48,    0,    0,   48,    0,
-  345,    0,   48,   48,    0,   48,   48,    0,   48,   48,
-   48,    0,    0,  345,   48,    0,    0,    0,  345,    0,
-    0,  345,    0,  345,    0,  345,  345,  345,  345,    0,
-    0,   48,    0,  345,    0,    0,    0,  345,    0,  227,
-    0,  345,    0,    0,    0,    0,  367,    0,    0,  345,
-    0,    0,  345,    0,  345,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,  367,
-    0,    0,    0,  345,    0,  345,  366,    0,    0,    0,
-    0,    0,  367,    0,  345,    0,  277,  367,  345,   48,
-  244,    0,  367,    0,  367,  367,  367,  367,    0,  366,
-    0,  345,  367,    0,    0,    0,  367,    0,    0,    0,
-  367,  439,  366,    0,    0,    0,    0,  366,  367,    0,
-  243,  367,  366,  367,  366,  366,  366,  366,    0,    0,
-    0,    0,  366,  345,  440,    0,  366,    0,    0,    0,
-  366,  439,    0,    0,  367,    0,    0,  441,  366,    0,
-    0,  366,  443,  366,    0,    0,    0,  444,    0,  445,
-  446,  447,  448,    0,  440,    0,    0,  449,    0,    0,
-    0,  450,    0,    0,  366, 1274,    0,  441,    0,    0,
-    0,    0,  443,  451,    0,    0,  452,  444,  453,  445,
-  446,  447,  448,    0,    0,    0,    0,  449,    0,    0,
-    0,  450,  367,    0,    0,    0,    0,    0,    0,  454,
-    0,    0,    0,  451,   57,   25,  452,   26,  453,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,    0,  366,    0,    0,   65,    0,    0,   31,  454,
-    0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
-   34,    0,   72,   73,   35,    0,  571,    0,    0,    0,
-    0,    0,    0,  572,    0,    0,   37, 1275,   38,   75,
-    0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,    0,    0,    0,    0,    0,
-    0,  573,    0,    0,   88,   89,    0, 1288,    0,    0,
+    0,   48,    0,   48,    0,   48,    0,   48,   48,   48,
+   48,    0,    0,   48,   48,    0,    0,    0,    0,   48,
+    0,   48,   48,   48,    0,    0,   48,    0,   48,    0,
+   48,    0,    0,   48,    0,   48,   48,   48,   48,    0,
+    0,    0,   48,   48,   48,    0,    0,   48,   48,   48,
+    0,    0,    0,    0,    0,    0,   48,   48,    0,   48,
+   48,    0,   48,   48,   48,    0,    0,    0,   48,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,    0,    0,    0,    0,
-   94,  884,    0,  574,    0,    0,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,   57,
-   25,    0,   26,    0,    0,   27,  253,    0,    0,    0,
-   28,   62,   63,    0,   29,    0,  104,  461,  106,  107,
-   65,    0,    0,   31,    0,    0,    0,    0,    0,    0,
-   33,    0,    0,    0,    0,   34,    0,   72,   73,   35,
-    0,  571,    0,    0,    0,    0,    0,    0,  572,    0,
-    0,   37,    0,   38,   75,    0,    0,   39,    0,    0,
-   77,    0,   79,    0,   81,   40,   41,  254,    0,   42,
-    0,    0,    0,    0,    0,    0,  573,    0,    0,   88,
-   89,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   90,   91,   92,    0,    0,
-    0,    0,    0,    0,    0,   94,    0,    0,  574,    0,
-    0,   96,   97,   98,   99,    0,    0,    0,  100,    0,
-  101,    0,    0,    0,    0,    0,  102,  103,    0,    0,
-    0,    0,    0,    0,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,  104,  461,  106,  107,   65,    0,    0,   31,    0,
-    0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
-   34,    0,   72,   73,   35,    0,  571,    0,    0,    0,
-    0,    0,    0,  572,    0,    0,   37,    0,   38,   75,
-    0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,    0,    0,    0,    0,    0,
-    0,  573,    0,    0,   88,   89,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,   48,    0,   48,    0,
+   48,    0,   48,    0,   81,   48,    0,   48,   48,    0,
+   48,    0,   48,   48,   48,    0,   48,   48,   48,   48,
+    0,    0,   48,   48,    0,    0,    0,    0,   48,    0,
+   48,   48,   48,    0,    0,   48,    0,   48,    0,   48,
+    0,    0,   48,    0,   48,   48,   48,   48,    0,    0,
+    0,   48,   48,   48,   48,    0,   48,   48,   48,    0,
+    0,    0,    0,    0,    0,   48,   48,    0,   48,   48,
+    0,   48,   48,   48,    0,    0,    0,   48,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,    0,    0,    0,    0,
-   94,    0,    0,    0,    0,    0,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,   57,
-   25,    0,   26,    0,    0,   27,  253,    0,    0,    0,
-   28,   62,   63,    0,   29,    0,  104,  461,  106,  107,
-   65,    0,    0,   31,    0,    0,    0,    0,    0,    0,
-   33,    0,    0,    0,    0,   34,    0,   72,   73,   35,
+    0,    0,    0,    0,    0,   48,    0,   48,    0,   48,
+    0,   48,    0,   82,   48,    0,   48,   48,    0,   48,
+    0,   48,   48,   48,    0,   48,   48,   48,   48,    0,
+    0,   48,   48,    0,    0,    0,    0,   48,    0,   48,
+   48,   48,    0,    0,   48,    0,   48,    0,   48,    0,
+    0,   48,    0,   48,   48,   48,   48,    0,    0,    0,
+   48,   48,   48,   48,    0,   48,   48,   48,    0,    0,
+    0,    0,    0,    0,   48,   48,    0,   48,   48,    0,
+   48,   48,   48,    0,    0,    0,   48,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   37,    0,   38,   75,    0,    0,   39,    0,    0,
-   77,    0,   79,    0,   81,   40,   41,  254,    0,   42,
-    0,    0,   85,    0,    0,    0,   87,    0,    0,   88,
-   89,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   90,   91,   92,    0,    0,
-    0,    0,    0,    0,    0,   94,    0,    0,    0,    0,
-    0,   96,   97,   98,   99,    0,    0,    0,  100,    0,
-  101,    0,    0,    0,    0,    0,  102,  103,    0,    0,
+    0,    0,    0,    0,   48,    0,   48,    0,   48,    0,
+   48,    0,  104,   48,    0,   48,   48,    0,   48,    0,
+   48,   48,   48,    0,   48,   48,   48,   48,    0,    0,
+   48,   48,    0,    0,    0,    0,   48,    0,   48,   48,
+   48,    0,    0,   48,    0,   48,    0,   48,    0,    0,
+   48,    0,   48,   48,   48,   48,    0,    0,    0,   48,
+   48,   48,   48,    0,   48,   48,   48,    0,    0,    0,
+    0,    0,    0,   48,   48,    0,   48,   48,    0,   48,
+   48,   48,    0,    0,    0,   48,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   48,    0,   48,    0,   48,    0,   48,
+    0,  105,   48,    0,   48,   48,    0,   48,    0,   48,
+   48,   48,    0,   48,   48,   48,   48,    0,    0,   48,
+   48,    0,    0,    0,    0,   48,    0,   48,   48,   48,
+    0,    0,   48,    0,   48,    0,   48,    0,    0,   48,
+    0,   48,   48,   48,   48,    0,    0,    0,   48,   48,
+   48,   48,    0,   48,   48,   48,    0,    0,    0,    0,
+    0,    0,   48,   48,    0,   48,   48,    0,   48,   48,
+   48,    0,    0,    0,   48,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   48,    0,    0,
+    0,   48,    0,   48,   48,    0,   48,    0,   48,   48,
+  226,   48,    0,   48,    0,   48,    0,   48,   48,   48,
+   48,    0,    0,   48,   48,    0,    0,    0,    0,   48,
+    0,   48,   48,   48,    0,    0,   48,    0,   48,  345,
+   48,    0,    0,   48,    0,   48,   48,   48,   48,    0,
+    0,    0,   48,   48,   48,    0,    0,   48,   48,   48,
+   48,    0,  345,    0,    0,    0,   48,   48,    0,   48,
+   48,  442,   48,   48,   48,  345,    0,    0,   48,    0,
+  345,    0,    0,  345,    0,  345,    0,  345,  345,  345,
+  345,    0,    0,    0,  443,  345,    0,    0,   48,  345,
+    0,    0,    0,  345,  227,    0,    0,  444,    0,  366,
+    0,  345,  446,    0,  345,    0,  345,  447,    0,  448,
+  449,  450,  451,    0,    0,    0,    0,  452,    0,    0,
+    0,  453,  366,    0,    0,  345,    0,    0,    0,  442,
+  345,    0,    0,  454,    0,  366,  455,  345,  456,  277,
+  366,  345,    0,  243,   48,  366,    0,  366,  366,  366,
+  366,    0,  443,    0,  345,  366,    0,    0,    0,  366,
+    0,    0,  457,  366,    0,  444,    0,    0,    0,    0,
+  446,  366,    0,    0,  366,  447,  366,  448,  449,  450,
+  451,    0,    0,    0,    0,  452,  345,    0,    0,  453,
+    0,    0,    0, 1277,    0,    0,   57,   25,    0,   26,
+  366,  454,   27,  255,  455,    0,  456,   28,   62,   63,
+    0,   29,    0,    0,    0,    0,    0,   65, 1291,    0,
+   31,    0,    0,    0,    0,    0,    0,   33,    0,    0,
+  457,    0,   34,    0,   72,   73,   35,    0,  574,    0,
+    0,    0,    0,    0,    0,  575,    0,    0,   37,    0,
+   38,   75,    0,    0,   39,    0,  366,   77,    0,   79,
+    0,   81,   40,   41,  256,    0,   42,    0,    0,    0,
+    0,    0,    0,  576,    0,    0,   88,   89,    0,    0,
+    0,    0,    0,    0,    0,    0, 1278,    0,    0,    0,
+    0,   90,   91,   92,    0,   93,    0,    0,    0,    0,
+    0,    0,    0,   95,  887,    0,  577,    0,    0,   97,
+   98,   99,  100,    0,    0,    0,  101,    0,  102,    0,
+    0,    0,    0,    0,  103,  104,    0,    0,    0,    0,
+    0,    0,   57,   25,    0,   26,    0,    0,   27,  255,
+    0,    0,    0,   28,   62,   63,    0,   29,    0,  105,
+  464,  107,  108,   65,    0,    0,   31,    0,    0,    0,
+    0,    0,    0,   33,    0,    0,    0,    0,   34,    0,
+   72,   73,   35,    0,  574,    0,    0,    0,    0,    0,
+    0,  575,    0,    0,   37,    0,   38,   75,    0,    0,
+   39,    0,    0,   77,    0,   79,    0,   81,   40,   41,
+  256,    0,   42,    0,    0,    0,    0,    0,    0,  576,
+    0,    0,   88,   89,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   90,   91,   92,
+    0,   93,    0,    0,    0,    0,    0,    0,    0,   95,
+    0,    0,  577,    0,    0,   97,   98,   99,  100,    0,
+    0,    0,  101,    0,  102,    0,    0,    0,    0,    0,
+  103,  104,    0,    0,    0,    0,    0,    0,   57,   25,
+    0,   26,    0,    0,   27,  255,    0,    0,    0,   28,
+   62,   63,    0,   29,    0,  105,  464,  107,  108,   65,
+    0,    0,   31,    0,    0,    0,    0,    0,    0,   33,
+    0,    0,    0,    0,   34,    0,   72,   73,   35,    0,
+  574,    0,    0,    0,    0,    0,    0,  575,    0,    0,
+   37,    0,   38,   75,    0,    0,   39,    0,    0,   77,
+    0,   79,    0,   81,   40,   41,  256,    0,   42,    0,
+    0,    0,    0,    0,    0,  576,    0,    0,   88,   89,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   90,   91,   92,    0,   93,    0,    0,
+    0,    0,    0,    0,    0,   95,    0,    0,    0,    0,
+    0,   97,   98,   99,  100,    0,    0,    0,  101,    0,
+  102,    0,    0,    0,    0,    0,  103,  104,    0,    0,
     0,    0,    0,    0,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,  104,  297,  106,  107,   65,    0,    0,   31,    0,
+   27,  255,    0,    0,    0,   28,   62,   63,    0,   29,
+    0,  105,  464,  107,  108,   65,    0,    0,   31,    0,
     0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
    34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,   37,    0,   38,   75,
     0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,    0,    0,    0,    0,    0,
+   40,   41,  256,    0,   42,    0,    0,   85,    0,    0,
     0,   87,    0,    0,   88,   89,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   90,
+   91,   92,    0,   93,    0,    0,    0,    0,    0,    0,
+    0,   95,    0,    0,    0,    0,    0,   97,   98,   99,
+  100,    0,    0,    0,  101,    0,  102,    0,    0,    0,
+    0,    0,  103,  104,    0,    0,    0,    0,    0,    0,
+   57,   25,    0,   26,    0,    0,   27,  255,    0,    0,
+    0,   28,   62,   63,    0,   29,    0,  105,  299,  107,
+  108,   65,    0,    0,   31,    0,    0,    0,    0,    0,
+    0,   33,    0,    0,    0,    0,   34,    0,   72,   73,
+   35,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,   37,    0,   38,   75,    0,    0,   39,    0,
+    0,   77,    0,   79,    0,   81,   40,   41,  256,    0,
+   42,    0,    0,    0,    0,    0,    0,   87,    0,    0,
+   88,   89,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   90,   91,   92,    0,   93,
+    0,    0,    0,    0,  848,    0,    0,   95,    0,    0,
+    0,    0,    0,   97,   98,   99,  100,    0,    0,    0,
+  101,    0,  102,    0,    0,    0,    0,    0,  103,  104,
+    0,    0,    0,    0,    0,    0,   57,   25,    0,   26,
+    0,    0,   27,  255,    0,    0,    0,   28,   62,   63,
+    0,   29,    0,  105,  299,  107,  108,   65,    0,    0,
+   31,    0,    0,    0,    0,    0,    0,   33,    0,    0,
+    0,    0,   34,    0,   72,   73,   35,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,   37,    0,
+   38,   75,    0,    0,   39,    0,    0,   77,    0,   79,
+    0,   81,   40,   41,  256,    0,   42,    0,    0,    0,
+    0,    0,    0,   87,    0,    0,   88,   89,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,    0,  845,    0,    0,
-   94,    0,    0,    0,    0,    0,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,   57,
-   25,    0,   26,    0,    0,   27,  253,    0,    0,    0,
-   28,   62,   63,    0,   29,    0,  104,  297,  106,  107,
-   65,    0,    0,   31,    0,    0,    0,    0,    0,    0,
-   33,    0,    0,    0,    0,   34,    0,   72,   73,   35,
+    0,   90,   91,   92,    0,   93,    0,    0,    0,  504,
+    0,    0,    0,   95,    0,    0,    0,    0,    0,   97,
+   98,   99,  100,    0,    0,    0,  101,    0,  102,    0,
+    0,    0,    0,    0,  103,  104,    0,    0,    0,    0,
+    0,    0,   57,   25,    0,   26,    0,    0,   27,  255,
+    0,    0,    0,   28,   62,   63,    0,   29,    0,  105,
+  299,  107,  108,   65,    0,    0,   31,    0,    0,    0,
+    0,    0,    0,   33,    0,    0,    0,    0,   34,    0,
+   72,   73,   35,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,   37,    0,   38,   75,    0,    0,
+   39,    0,    0,   77,    0,   79,    0,   81,   40,   41,
+  256,    0,   42,    0,    0,    0,    0,    0,    0,   87,
+    0,    0,   88,   89,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,   90,   91,   92,
+    0,   93,    0,    0,    0,  498,    0,    0,    0,   95,
+    0,    0,    0,    0,    0,   97,   98,   99,  100,    0,
+    0,    0,  101,    0,  102,    0,    0,    0,    0,    0,
+  103,  104,    0,    0,    0,    0,    0,    0,   57,   25,
+    0,   26,    0,    0,   27,  255,    0,    0,    0,   28,
+   62,   63,    0,   29,    0,  105,  299,  107,  108,   65,
+    0,    0,   31,    0,    0,    0,    0,    0,    0,   33,
+    0,    0,    0,    0,   34,    0,   72,   73,   35,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   37,    0,   38,   75,    0,    0,   39,    0,    0,
-   77,    0,   79,    0,   81,   40,   41,  254,    0,   42,
-    0,    0,    0,    0,    0,    0,   87,    0,    0,   88,
-   89,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   90,   91,   92,    0,    0,
-    0,  501,    0,    0,    0,   94,    0,    0,    0,    0,
-    0,   96,   97,   98,   99,    0,    0,    0,  100,    0,
-  101,    0,    0,    0,    0,    0,  102,  103,    0,    0,
+   37,    0,   38,   75,    0,    0,   39,    0,    0,   77,
+    0,   79,    0,   81,   40,   41,  256,    0,   42,    0,
+    0,    0,    0,    0,    0,   87,    0,    0,   88,   89,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   90,   91,   92,    0,   93,    0,    0,
+    0,    0,    0,    0,    0,   95,    0,    0,    0,    0,
+    0,   97,   98,   99,  100,    0,    0,    0,  101,    0,
+  102,    0,    0,    0,    0,    0,  103,  104,    0,    0,
     0,    0,    0,    0,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,  104,  297,  106,  107,   65,    0,    0,   31,    0,
+   27,  255,    0,    0,    0,   28,   62,   63,    0,   29,
+    0,  105,  299,  107,  108,   65,    0,    0,   31,    0,
     0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
    34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,   37,    0,   38,   75,
     0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,    0,    0,    0,    0,    0,
+   40,   41,  256,    0,   42,    0,    0,    0,    0,    0,
     0,   87,    0,    0,   88,   89,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   90,
+   91,   92,    0,   93,    0,    0,    0,    0,    0,    0,
+    0,   95,    0,    0,    0,    0,    0,   97,   98,   99,
+  100,    0,    0,    0,  101,    0,  102,    0,    0,    0,
+    0,    0,  103,  104,    0,    0,    0,    0,    0,    0,
+   57,   25,    0,   26,    0,    0,   27,  255,    0,    0,
+    0,   28,   62,   63,    0,   29,    0,  105,  464,  107,
+  108,   65,    0,    0,   31,    0,    0,    0,    0,    0,
+    0,   33,    0,    0,    0,    0,   34,    0,   72,   73,
+   35,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,   37,    0,   38,   75,    0,    0,   39,    0,
+    0,   77,    0,   79,    0,   81,   40,   41,  256,    0,
+   42,    0,    0,    0,    0,    0,    0,   87,    0,    0,
+   88,   89,    0,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,   90,   91,   92,    0,   93,
+    0,    0,    0,    0,    0,    0,    0,   95,    0,    0,
+    0,    0,    0,   97,   98,   99,  100,    0,    0,    0,
+  101,    0,  102,    0,    0,    0,    0,    0,  103,  104,
+    0,    0,    0,    0,    0,    0,   78,   78,    0,   78,
+    0,    0,   78,   78,    0,    0,    0,   78,   78,   78,
+    0,   78,    0,  105,  995,  107,  108,   78,    0,    0,
+   78,    0,    0,    0,    0,    0,    0,   78,    0,    0,
+    0,    0,   78,    0,   78,   78,   78,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,   78,    0,
+   78,   78,    0,    0,   78,    0,    0,   78,    0,   78,
+    0,   78,   78,   78,   78,    0,   78,    0,    0,    0,
+    0,    0,    0,   78,    0,    0,   78,   78,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,  495,    0,    0,    0,
-   94,    0,    0,    0,    0,    0,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,   57,
-   25,    0,   26,    0,    0,   27,  253,    0,    0,    0,
-   28,   62,   63,    0,   29,    0,  104,  297,  106,  107,
-   65,    0,    0,   31,    0,    0,    0,    0,    0,    0,
-   33,    0,    0,    0,    0,   34,    0,   72,   73,   35,
+    0,   78,   78,   78,    0,   78,    0,    0,    0,    0,
+    0,    0,    0,   78,    0,    0,    0,    0,    0,   78,
+   78,   78,   78,    0,    0,    0,   78,    0,   78,    0,
+    0,    0,    0,    0,   78,   78,    0,    0,    0,    0,
+    0,    0,  150,  150,    0,  150,    0,    0,  150,  150,
+    0,    0,    0,  150,  150,  150,    0,  150,    0,   78,
+   78,   78,   78,  150,    0,    0,  150,    0,    0,    0,
+    0,    0,    0,  150,    0,    0,    0,    0,  150,    0,
+  150,  150,  150,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,  150,    0,  150,  150,    0,    0,
+  150,    0,    0,  150,    0,  150,    0,  150,  150,  150,
+  150,    0,  150,    0,    0,    0,    0,    0,    0,  150,
+    0,    0,  150,  150,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,  150,  150,  150,
+    0,  150,    0,    0,    0,    0,    0,    0,    0,  150,
+    0,    0,    0,    0,    0,  150,  150,  150,  150,    0,
+    0,    0,  150,    0,  150,    0,    0,    0,    0,    0,
+  150,  150,    0,    0,    0,    0,    0,    0,   57,   25,
+    0,   26,    0,    0,   27,  255,    0,    0,    0,   28,
+   62,   63,    0,   29,    0,  150,  150,  150,  150,   65,
+    0,    0,   31,    0,    0,    0,    0,    0,    0,   33,
+    0,   28,    0,    0,   34,    0,   72,   73,   35,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   37,    0,   38,   75,   28,    0,   39,    0,    0,   77,
+    0,   79,    0,   81,   40,   41,  256,   28,   42,    0,
+    0,    0,   28,    0,    0,    0,    0,   28,    0,   28,
+   28,   28,   28,    0,    0,   28,    0,   28,    0,    0,
+    0,   28,    0,   90,   91,   92,    0,   93,    0,    0,
+    0,    0,    0,   28,    0,   95,   28,    0,   28,    0,
+    0,   97,   98,   99,  100,    0,    0,    0,  101,    0,
+  102,    0,   57,   25,    0,   26,  103,  104,   27,  255,
+    0,    0,   28,   28,   62,   63,    0,   29,   28,   28,
+    0,    0,    0,   65,    0,    0,   31,    0,    0,    0,
+   48,  105,  257,   33,  108,    0,    0,    0,   34,    0,
+   72,   73,   35,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,   48,   37,    0,   38,   75,    0,    0,
+   39,    0,    0,   77,    0,   79,   48,   81,   40,   41,
+  256,   48,   42,    0,    0,    0,   48,    0,   48,   48,
+   48,   48,    0,    0,   48,    0,   48,    0,    0,    0,
+   48,    0,    0,    0,    0,    0,    0,   90,   91,   92,
+    0,   93,   48,    0,    0,   48,    0,   48,    0,   95,
+  644,    0,  644,    0,  644,   97,    0,  644,  100,  644,
+  644,    0,  644,    0,  644,    0,  644,    0,  644,  644,
+  644,   48,    0,    0,  644,  644,    0,  310,    0,    0,
+  644,    0,  644,  644,    0,    0,    0,  644,    0,    0,
+    0,  644,    0,    0,    0,  105,  257,    0,  108,    0,
+    0,    0,  644,  644,    0,  644,    0,    0,    0,  644,
+  644,    0,    0,    0,    0,    0,    0,  644,  644,   57,
+   25,  644,   26,    0,  644,   27,  255,    0,    0,  644,
+   28,   62,   63,    0,   29,    0,    0,    0,    0,    0,
+   65,    0,    0,   31,    0,    0,    0,    0,    0,    0,
+   33,  644,  644,    0,    0,   34,    0,   72,   73,   35,
+    0,    0,    0,    0,  644,    0,    0,    0,    0,    0,
     0,   37,    0,   38,   75,    0,    0,   39,    0,    0,
-   77,    0,   79,    0,   81,   40,   41,  254,    0,   42,
-    0,    0,    0,    0,    0,    0,   87,    0,    0,   88,
-   89,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   90,   91,   92,    0,    0,
-    0,    0,    0,    0,    0,   94,    0,    0,    0,    0,
-    0,   96,   97,   98,   99,    0,    0,    0,  100,    0,
-  101,    0,    0,    0,    0,    0,  102,  103,    0,    0,
-    0,    0,    0,    0,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,  104,  297,  106,  107,   65,    0,    0,   31,    0,
-    0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
-   34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   37,    0,   38,   75,
-    0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,    0,    0,    0,    0,    0,
-    0,   87,    0,    0,   88,   89,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   90,   91,   92,    0,    0,    0,    0,    0,    0,    0,
-   94,    0,    0,    0,    0,    0,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,    0,    0,    0,
-    0,  102,  103,    0,    0,    0,    0,    0,    0,   57,
-   25,    0,   26,    0,    0,   27,  253,    0,    0,    0,
-   28,   62,   63,    0,   29,    0,  104,  461,  106,  107,
-   65,    0,    0,   31,    0,    0,    0,    0,    0,    0,
-   33,    0,    0,    0,    0,   34,    0,   72,   73,   35,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,   37,    0,   38,   75,    0,    0,   39,    0,    0,
-   77,    0,   79,    0,   81,   40,   41,  254,    0,   42,
-    0,    0,    0,    0,    0,    0,   87,    0,    0,   88,
-   89,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,   90,   91,   92,    0,    0,
-    0,    0,    0,    0,    0,   94,    0,    0,    0,    0,
-    0,   96,   97,   98,   99,    0,    0,    0,  100,    0,
-  101,    0,    0,    0,    0,    0,  102,  103,    0,    0,
-    0,    0,    0,    0,   78,   78,    0,   78,    0,    0,
-   78,   78,    0,    0,    0,   78,   78,   78,    0,   78,
-    0,  104,  992,  106,  107,   78,    0,    0,   78,    0,
-    0,    0,    0,    0,    0,   78,    0,    0,    0,    0,
-   78,    0,   78,   78,   78,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   78,    0,   78,   78,
-    0,    0,   78,    0,    0,   78,    0,   78,    0,   78,
-   78,   78,   78,    0,   78,    0,    0,    0,    0,    0,
-    0,   78,    0,    0,   78,   78,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-   78,   78,   78,    0,    0,    0,    0,    0,    0,    0,
-   78,    0,    0,    0,    0,    0,   78,   78,   78,   78,
-    0,    0,    0,   78,    0,   78,    0,    0,    0,    0,
-    0,   78,   78,    0,    0,    0,    0,    0,    0,  150,
-  150,    0,  150,    0,    0,  150,  150,    0,    0,    0,
-  150,  150,  150,    0,  150,    0,   78,   78,   78,   78,
-  150,    0,    0,  150,    0,    0,    0,    0,    0,    0,
-  150,    0,    0,    0,    0,  150,    0,  150,  150,  150,
-    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,  150,    0,  150,  150,    0,    0,  150,    0,    0,
-  150,    0,  150,    0,  150,  150,  150,  150,    0,  150,
-    0,    0,    0,    0,    0,    0,  150,    0,    0,  150,
-  150,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,  150,  150,  150,    0,    0,
-    0,    0,    0,    0,    0,  150,    0,    0,    0,    0,
-    0,  150,  150,  150,  150,    0,    0,    0,  150,    0,
-  150,    0,    0,    0,    0,    0,  150,  150,    0,    0,
-    0,    0,    0,    0,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,  150,  150,  150,  150,   65,    0,    0,   31,    0,
+   77,    0,   79,    0,   81,   40,   41,  256,    0,   42,
+    0,    0,   85,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,    0,  644,    0,    0,    0,    0,
+    0,    0,    0,    0,   90,   91,   92,  643,    0,  643,
+    0,    0,  643,    0,  643,  643,   95,  643,    0,  643,
+    0,  643,    0,  643,  643,  643,    0,    0,    0,  643,
+  643,    0,    0,    0,    0,  643,    0,  643,  643,    0,
+    0,    0,  643,    0,    0,    0,  643,    0,    0,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,  643,    0,
+  643,    0,  105,  257,  643,  643,    0,    0,    0,    0,
+    0,    0,  643,  643,    0,  643,  643,  643,    0,  643,
+  643,    0,  643,  643,  643,  643,    0,  643,    0,  643,
+    0,  643,  643,  643,    0,    0,    0,  643,  643,    0,
+    0,    0,    0,  643,    0,  643,  643,    0,    0,    0,
+  643,    0,    0,    0,  643,    0,    0,    0,    0,  643,
+    0,    0,    0,    0,    0,    0,  643,    0,  643,    0,
+    0,    0,  643,  643,    0,    0,    0,    0,    0,    0,
+  643,  643,    0,    0,  643,    0,    0,  643,    0,   25,
+    0,   26,  643,    0,   27,    0,    0, 1246,    0,   28,
+  643,  663,    0,   29,    0,  664, 1247, 1248,    0,    0,
+    0, 1249,   31,    0,    0,    0,    0, 1250,    0,   33,
+    0,   25,    0,   26,   34,    0,   27,    0,   35, 1246,
+    0,   28,    0,  663,    0,   29,    0,  664, 1247, 1248,
+   37,    0,   38, 1249,   31,    0,   39,    0,    0, 1250,
+    0,   33,    0,    0,   40,   41,   34,    0,   42,    0,
+   35, 1251,    0,    0,    0,   48, 1252,   48,  643,    0,
+   48,    0,   37,    0,   38,   48,    0,    0,   39,   48,
+    0,    0,    0,    0,    0,    0,   40,   41,   48,    0,
+   42,    0,    0, 1251,    0,   48,    0,   48, 1252,   48,
+   48, 1253,   48,    0,   48,    0,   48,   48,   48,    0,
+    0,   48,    0,   48,    0,    0,   48,    0,   48,    0,
+   48,    0,   48,    0,    0,   48,    0,   48,    0,    0,
+   48,   48,   48,    0,   48,    0,   48,   48,   48,    0,
+   48,   48, 1254,   48,    0,   48,   48,    0,   48,    0,
+   48,   48,    0,    0,   48,   48,    0,   48,    0,    0,
+    0,    0,   48,   48,   48,    0,   48,    0,    0,   48,
+    0,   48,  167,   25, 1254,   26,   48,    0,   27,    0,
+   48,    0,   48,   28,   48,    0,    0,   29,    0,   48,
+    0,    0,   48,    0,   48,    0,   31,    0,   48,    0,
+    0,   48,  167,   33,    0,    0,   48,   48,   34,    0,
+   48,    0,   35,   48,  555,    0,    0,    0,   48,    0,
+    0,  556,    0,    0,   37,    0,   38,    0,    0,    0,
+   39,    0,    0,  557,    0,    0,    0,    0,   40,   41,
+    0,    0,   42,    0,   25,  558,   26,    0,    0,   27,
+   48, 1173,    0,    0,   28,    0,    0,    0,   29,    0,
+    0,    0,    0,    0,    0,    0,    0,   31,   25,    0,
+   26,    0,    0,   27,   33,    0,    0,    0,   28,   34,
+    0, 1174,   29,   35,    0,    0,   30,    0,    0,    0,
+    0,   31,    0,    0,   48,   37,   32,   38,   33,    0,
+    0,   39, 1175,   34,    0,    0,    0,   35,   36,   40,
+   41,    0,    0,   42,    0,    0,  317,    0,   25,   37,
+   26,   38,    0,   27,    0,   39,  559,    0,   28,    0,
+    0,    0,   29,   40,   41,    0,    0,   42,    0,    0,
+    0,   31,   25,    0,   26,    0,    0,   27,   33,    0,
+    0,    0,   28,   34,    0,    0,   29,   35,    0,    0,
+    0,    0,    0,    0,    0,   31,    0,    0,    0,   37,
+    0,   38,   33,    0,    0,   39,    0,   34,    0,    0,
+    0,   35,    0,   40,   41,    0,    0,   42,    0,    0,
+  317,    0,    0,   37,    0,   38,   25,  349,   26,   39,
+    0,   27,    0,    0,    0,    0,   28,   40,   41,    0,
+   29,   42,    0,   25,  317,   26,    0,    0,   27,   31,
+    0,   43,    0,   28,    0,    0,   33,   29,    0,    0,
+    0,   34,    0,    0,    0,   35,   31,    0,    0,    0,
+    0,    0,    0,   33,    0,    0,    0,   37,   34,   38,
+    0,    0,   35,   39,    0,    0,    0,    0,    0,    0,
+    0,   40,   41,    0,   37,   42,   38,   25,  506,   26,
+   39,  324,   27,    0,    0,    0,    0,   28,   40,   41,
+    0,   29,   42,    0,    0,  317,    0,    0,    0,    0,
+   31,   25,    0,   26,    0,  349,   27,   33,    0,    0,
+    0,   28,   34,    0,    0,   29,   35,    0,    0,    0,
+    0,    0,    0,    0,   31,    0,    0,    0,   37,    0,
+   38,   33,    0,    0,   39,    0,   34,    0,    0,    0,
+   35,    0,   40,   41,    0,    0,   42,    0,    0,  317,
+    0,   25,   37,   26,   38,    0,   27,    0,   39,  349,
+    0,   28,    0,    0,    0,   29,   40,   41,    0,    0,
+   42,    0,    0,  558,   31,  497,  622,  497,    0,    0,
+  497,   33,    0,    0,    0,  497,   34,    0,    0,  497,
+   35,    0,    0,    0,    0,    0,    0,    0,  497,    0,
+    0,    0,   37,    0,   38,  497,    0,    0,   39,    0,
+  497,    0,    0,    0,  497,    0,   40,   41,    0,    0,
+   42,    0,    0,  731,    0,    0,  497,    0,  497,  187,
+  624,  187,  497,    0,  187,    0,    0,    0,    0,  187,
+  497,  497,    0,  187,  497,    0,  186,  497,  186,    0,
+    0,  186,  187,    0,  349,    0,  186,    0,    0,  187,
+  186,    0,    0,    0,  187,    0,    0,    0,  187,  186,
+    0,    0,    0,    0,    0,    0,  186,    0,    0,    0,
+  187,  186,  187,    0,    0,  186,  187,    0,    0,    0,
+    0,    0,    0,    0,  187,  187,    0,  186,  187,  186,
+  196,  187,  196,  186,  349,  196,    0,    0,    0,    0,
+  196,  186,  186,    0,  196,  186,    0,    0,  186,    0,
+    0,    0,    0,  196,    0,    0,    0,    0,  497,    0,
+  196,    0,    0,    0,    0,  196,    0,    0,   35,  196,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,   35,
+    0,  196,    0,  196,   35,    0,    0,  196,   35,    0,
+    0,   35,    0,    0,    0,  196,  196,    0,    0,  196,
+    0,    0,  196,   35,   35,    0,    0,    0,   35,   35,
+    0,    0,  187,    0,   35,    0,   35,   35,   35,   35,
+    0,    0,    0,    0,   35,    0,    0,    0,   35,  186,
+   35,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+   35,    0,   35,   35,   33,   35,    0,    0,    0,   35,
     0,    0,    0,    0,    0,   33,    0,    0,    0,    0,
-   34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   37,    0,   38,   75,
-    0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,    0,   25,    0,   26,    0,
-    0,   27,    0, 1170,    0,    0,   28,    0,    0,    0,
-   29,    0,    0,    0,    0,    0,    0,    0,    0,   31,
-   90,   91,   92,    0,    0,    0,   33,    0,    0,    0,
-   94,   34,    0, 1171,    0,   35,   96,   97,   98,   99,
-    0,    0,    0,  100,    0,  101,    0,   37,    0,   38,
-    0,  102,  103,   39, 1172,    0,    0,    0,    0,    0,
-    0,   40,   41,    0,    0,   42,    0,    0,  315,    0,
-    0,  642,    0,  642,    0,  642,  104,  255,  642,  107,
-  642,  642,    0,  642,    0,  642,    0,  642,    0,  642,
-  642,  642,    0,    0,    0,  642,  642,    0,    0,    0,
-    0,  642,    0,  642,  642,    0,    0,    0,  642,    0,
-    0,    0,  642,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,    0,  642,  642,    0,  642,    0,    0,    0,
-  642,  642,    0,    0,    0,    0,    0,    0,  642,  642,
-    0,    0,  642,    0,    0,  642,    0,    0,  346,    0,
-  642,    0,    0,    0,   57,   25,    0,   26,    0,    0,
-   27,  253,    0,    0,    0,   28,   62,   63,    0,   29,
-    0,  642,  642,    0,    0,   65,    0,    0,   31,    0,
-    0,    0,    0,    0,  642,   33,    0,    0,    0,    0,
-   34,    0,   72,   73,   35,    0,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,   37,    0,   38,   75,
-    0,    0,   39,    0,    0,   77,    0,   79,    0,   81,
-   40,   41,  254,    0,   42,  642,  641,   85,  641,    0,
-    0,  641,    0,  641,  641,    0,  641,    0,  641,    0,
-  641,    0,  641,  641,  641,    0,    0,    0,  641,  641,
-   90,   91,   92,    0,  641,    0,  641,  641,    0,    0,
-   94,  641,    0,    0,    0,  641,    0,    0,    0,    0,
-    0,    0,    0,    0,    0,    0,    0,  641,    0,  641,
-    0,    0,    0,  641,  641,    0,    0,    0,    0,    0,
-    0,  641,  641,    0,    0,  641,    0,    0,  641,    0,
-    0,    0,    0,  641,    0,    0,  104,  255,  641,    0,
-  641,    0,    0,  641,    0,  641,  641,    0,  641,    0,
-  641,    0,  641,    0,  641,  641,  641,    0,    0,    0,
-  641,  641,    0,    0,    0,    0,  641,  641,  641,  641,
-   25,    0,   26,  641,    0,   27,    0,  641, 1243,    0,
-   28,    0,  660,    0,   29,    0,  661, 1244, 1245,  641,
-    0,  641, 1246,   31,    0,  641,  641,    0, 1247,    0,
-   33,    0,    0,  641,  641,   34,    0,  641,  641,   35,
-  641,    0,    0,    0,    0,  641,    0,    0,    0,    0,
-    0,   37,    0,   38,    0,    0,    0,   39,    0,    0,
-    0,    0,    0,    0,    0,   40,   41,    0,   25,   42,
-   26,    0, 1248,   27,    0,    0, 1243, 1249,   28,    0,
-  660,    0,   29,    0,  661, 1244, 1245,    0,    0,    0,
- 1246,   31,    0,    0,    0,    0, 1247,    0,   33,    0,
-   48,    0,   48,   34,    0,   48,    0,   35,    0,    0,
-   48, 1250,    0,    0,   48,    0,    0,    0,    0,   37,
-  641,   38,    0,   48,    0,   39,    0,    0,    0,    0,
-   48,    0,    0,   40,   41,   48,    0,   42,    0,   48,
- 1248,   48,    0,   48,   48, 1249,   48,    0,   48,   48,
-    0,   48, 1251,   48,   48,    0,    0,   48,   48,    0,
-   48,    0,    0,    0,    0,   48,   48,   48,    0,   48,
-    0,    0,   48,    0,   48,    0,    0,    0,    0,   48,
-    0,    0,    0,   48,   48,   48,   48,   48,    0,   48,
-    0,    0,   48,    0,   48,   48,    0,   48,   48,    0,
-    0,   48,    0,    0,   48,    0,  167,   48,    0,   48,
-   48,    0,    0,   48,   48,    0,   48,    0,    0,   48,
- 1251,    0,    0,   48,    0,   48,    0,   48,   25,    0,
-   26,    0,   48,   27,    0,   48,    0,   48,   28,    0,
-    0,   48,   29,    0,   48,    0,    0,    0,  167,   48,
-   48,   31,   48,   48,    0,    0,   48,    0,   33,    0,
-    0,    0,    0,   34,    0,    0,    0,   35,    0,  552,
-    0,    0,    0,    0,    0,    0,  553,    0,    0,   37,
-    0,   38,    0,    0,    0,   39,    0,    0,  554,    0,
-    0,    0,    0,   40,   41,    0,   48,   42,    0,   25,
-  555,   26,    0,    0,   27,    0,    0,    0,    0,   28,
-   25,    0,   26,   29,    0,   27,    0,   30,    0,    0,
-   28,    0,   31,    0,   29,    0,    0,   32,    0,   33,
-    0,    0,    0,   31,   34,    0,   48,    0,   35,   36,
-   33,    0,    0,    0,    0,   34,    0,    0,    0,   35,
-   37,    0,   38,    0,    0,    0,   39,    0,    0,    0,
-    0,   37,    0,   38,   40,   41,    0,   39,   42,    0,
-    0,    0,    0,    0,    0,   40,   41,    0,    0,   42,
-  556,   25,  315,   26,    0,    0,   27,    0,    0,    0,
-    0,   28,   25,    0,   26,   29,    0,   27,    0,    0,
-    0,    0,   28,    0,   31,    0,   29,    0,    0,    0,
-    0,   33,    0,    0,    0,   31,   34,    0,    0,    0,
-   35,    0,   33,    0,    0,    0,    0,   34,    0,    0,
-    0,   35,   37,    0,   38,    0,    0,    0,   39,    0,
-    0,    0,    0,   37,    0,   38,   40,   41,    0,   39,
-   42,   43,    0,  315,    0,    0,    0,   40,   41,    0,
-    0,   42,  316,   25,  315,   26,    0,    0,   27,    0,
-    0,    0,    0,   28,   25,    0,   26,   29,    0,   27,
-    0,    0,    0,    0,   28,    0,   31,    0,   29,    0,
-    0,    0,    0,   33,    0,    0,    0,   31,   34,    0,
-    0,    0,   35,    0,   33,    0,    0,    0,    0,   34,
-    0,    0,    0,   35,   37,    0,   38,    0,    0,    0,
-   39,    0,    0,    0,    0,   37,    0,   38,   40,   41,
-    0,   39,   42,  322,    0,  503,    0,    0,    0,   40,
-   41,    0,    0,   42,  346,   25,  315,   26,    0,    0,
-   27,    0,    0,    0,    0,   28,   25,    0,   26,   29,
-    0,   27,    0,    0,    0,    0,   28,    0,   31,    0,
-   29,    0,    0,    0,    0,   33,    0,    0,    0,   31,
-   34,    0,    0,    0,   35,    0,   33,    0,    0,    0,
-    0,   34,    0,    0,    0,   35,   37,    0,   38,    0,
-    0,    0,   39,    0,    0,    0,    0,   37,    0,   38,
-   40,   41,    0,   39,   42,  346,    0,  315,    0,    0,
-    0,   40,   41,    0,    0,   42,  619,   25,  555,   26,
-    0,    0,   27,    0,    0,    0,    0,   28,  497,    0,
-  497,   29,    0,  497,    0,    0,    0,    0,  497,    0,
-   31,    0,  497,    0,    0,    0,    0,   33,    0,    0,
-    0,  497,   34,    0,    0,    0,   35,    0,  497,    0,
-    0,    0,    0,  497,    0,    0,    0,  497,   37,    0,
-   38,    0,    0,    0,   39,    0,    0,    0,    0,  497,
-    0,  497,   40,   41,    0,  497,   42,  621,    0,  728,
-    0,    0,    0,  497,  497,    0,    0,  497,  346,  187,
-  497,  187,    0,    0,  187,    0,    0,    0,    0,  187,
-  186,    0,  186,  187,    0,  186,    0,    0,    0,    0,
-  186,    0,  187,    0,  186,    0,    0,    0,    0,  187,
-    0,    0,    0,  186,  187,    0,    0,    0,  187,    0,
-  186,    0,    0,    0,    0,  186,    0,    0,    0,  186,
-  187,    0,  187,    0,    0,    0,  187,    0,    0,    0,
-    0,  186,    0,  186,  187,  187,    0,  186,  187,  346,
-    0,  187,    0,    0,    0,  186,  186,    0,    0,  186,
-  497,  196,  186,  196,    0,    0,  196,    0,    0,    0,
-    0,  196,    0,    0,    0,  196,    0,    0,    0,    0,
-    0,    0,    0,    0,  196,    0,    0,    0,   35,    0,
-    0,  196,    0,    0,    0,    0,  196,    0,    0,   35,
-  196,    0,    0,    0,   35,    0,    0,    0,   35,    0,
-    0,   35,  196,    0,  196,    0,    0,    0,  196,    0,
-    0,    0,    0,   35,   35,    0,  196,  196,   35,   35,
-  196,  187,    0,  196,   35,    0,   35,   35,   35,   35,
-    0,    0,  186,    0,   35,    0,    0,    0,   35,    0,
-   35,    0,    0,    0,    0,    0,   33,    0,    0,    0,
-   35,    0,   35,   35,    0,   35,    0,   33,    0,   35,
-    0,    0,   33,    0,    0,    0,   33,    0,    0,   33,
-    0,    0,    0,    0,    0,    0,   35,    0,    0,    0,
-    0,   33,   33,    0,   35,   35,   33,   33,    0,   28,
-    0,    0,   33,    0,   33,   33,   33,   33,    0,    0,
-    0,    0,   33,  196,    0,    0,   33,    0,   33,    0,
-    0,    0,   28,    0,    0,    0,    0,    0,   33,    0,
-    0,   33,    0,   33,    0,   28,    0,   33,    0,    0,
-   28,    0,   28,    0,   28,   28,    0,   28,   28,   28,
-   28,    0,    0,   28,   33,   28,    0,    0,    0,   28,
-    0,    0,   33,   33,    0,   28,    0,    0,    0,    0,
-    0,   28,    0,    0,   28,    0,   28,    0,   28,    0,
-    0,    0,    0,   28,    0,    0,    0,    0,   28,    0,
-   28,   28,   28,   28,    0,    0,    0,   28,   28,    0,
-    0,    0,   28,    0,    0,   28,   28,    0,    0,    0,
-   48,    0,    0,    0,   28,    0,    0,   28,    0,   28,
-    0,   48,    0,    0,    0,    0,   48,    0,    0,    0,
-   48,    0,    0,   48,    0,    0,    0,    0,    0,    0,
-   28,    0,    0,    0,    0,   48,   48,    0,   28,   28,
-   48,   48,    0,   48,    0,    0,   48,    0,   48,   48,
-   48,   48,    0,    0,   48,    0,   48,    0,    0,   48,
-   48,    0,   48,   48,    0,    0,   48,    0,    0,    0,
-    0,    0,   48,    0,    0,   48,    0,   48,   48,   48,
-    0,   48,    0,   48,   48,    0,   48,    0,    0,   48,
-    0,   48,   48,   48,   48,    0,    0,    0,   48,   48,
-    0,    0,    0,   48,    0,   48,   37,    0,    0,   48,
-    0,    0,    0,    0,    0,   48,    0,    0,   48,    0,
-   48,   48,   48,    0,   48,    0,    0,   48,    0,    0,
-    0,    0,   48,    0,   48,   48,   48,   48,    0,    0,
-    0,   48,   48,    0,   48,    0,   48,    0,    0,   38,
-    0,    0,    0,    0,    0,    0,    0,   48,   48,    0,
-    0,   48,   48,   48,    0,    0,    0,   48,    0,   48,
-   48,   48,   48,    0,    0,    0,    0,   48,    0,    0,
-   48,   48,   48,    0,   48,    0,    0,    0,   48,   48,
-    0,    0,  208,   48,    0,    0,   48,    0,   48,    0,
-    0,    0,    0,   48,    0,    0,    0,    0,    0,    0,
-   48,    0,    0,    0,    0,    0,   48,    0,    0,   48,
-    0,   48,    0,   48,   48,    0,   48,  210,   48,   48,
-   48,   48,    0,   48,    0,    0,   48,    0,    0,    0,
-   48,    0,    0,    0,    0,    0,   48,    0,    0,    0,
-    0,   48,   48,    0,    0,   48,   48,   48,   48,   48,
-   48,   48,    0,    0,    0,    0,   48,    0,    0,   48,
-   48,   48,    0,    0,    0,    0,    0,    0,   48,    0,
-    0,    0,   48,    0,    0,   48,  311,   48,    0,    0,
-    0,    0,   48,    0,    0,    0,    0,    0,    0,  439,
-    0,    0,    0,    0,    0,   48,    0,    0,   48,    0,
-   48,    0,   48,   48,    0,   48,    0,   48,   48,   48,
-   48,    0,  440,   48,    0,   48,    0,    0,    0,   48,
-    0,    0,    0,    0,  439,  441,    0,    0,    0,  442,
-  443,   48,    0,    0,   48,  444,   48,  445,  446,  447,
-  448,    0,    0,    0,    0,  449,    0,  440,    0,  450,
-    0,    0,    0,    0,    0,    0,    0,   48,    0,    0,
-  441,  451,    0,    0,  452,  443,  453,    0,    0,    0,
-  444,    0,  445,  446,  447,  448,    0,    0,    0,    0,
-  449,    0,    0,    0,  450,    0,    0,  454,    0,    0,
-    0,    0,    0,    0,    0,    0,  451,    0,    0,  452,
-    0,  453,    0,    0,    0,    0,    0,    0,    0,    0,
+   33,    0,    0,    0,   33,    0,    0,   33,    0,   35,
+    0,    0,    0,    0,    0,   35,   35,    0,    0,   33,
+   33,    0,    0,  196,   33,   33,   28,    0,   28,    0,
+   33,    0,   33,   33,   33,   33,    0,    0,    0,    0,
+   33,    0,    0,    0,   33,    0,   33,    0,    0,   28,
+    0,    0,    0,    0,    0,    0,   33,    0,    0,   33,
+    0,   33,   28,    0,    0,   33,    0,   28,    0,    0,
+    0,    0,   28,    0,   28,   28,   28,   28,    0,    0,
+    0,    0,   28,    0,    0,   33,   28,    0,    0,   48,
+    0,   33,   33,    0,    0,    0,    0,    0,   28,    0,
+   48,   28,    0,   28,    0,   48,    0,    0,    0,   48,
+    0,    0,   48,    0,    0,    0,    0,    0,    0,    0,
+    0,    0,    0,    0,   48,   48,    0,   28,    0,   48,
+   48,    0,   48,   28,   28,   48,    0,   48,   48,   48,
+   48,    0,    0,   48,    0,   48,    0,    0,   48,   48,
+    0,   48,   48,    0,    0,   48,    0,    0,    0,    0,
+    0,   48,    0,    0,   48,    0,   48,   48,   48,    0,
+   48,    0,   48,   48,   48,    0,    0,    0,   48,    0,
+   48,   48,   48,   48,    0,    0,    0,    0,   48,    0,
+   48,    0,   48,    0,   48,    0,   37,   48,    0,    0,
+    0,    0,    0,    0,   48,    0,    0,   48,    0,   48,
+   48,    0,   48,   48,    0,   48,    0,    0,    0,    0,
+   48,    0,   48,   48,   48,   48,    0,    0,    0,    0,
+   48,    0,    0,   48,   48,   48,    0,    0,    0,   38,
+    0,    0,    0,    0,    0,    0,   48,    0,   48,   48,
+   48,   48,   48,   48,    0,    0,    0,    0,   48,    0,
+   48,   48,   48,   48,    0,    0,    0,    0,   48,    0,
+    0,    0,   48,   48,    0,   48,    0,   48,   48,    0,
+    0,  208,    0,    0,   48,    0,   48,   48,   48,   48,
+    0,   48,    0,    0,    0,    0,   48,    0,   48,   48,
+   48,   48,    0,    0,    0,    0,   48,    0,    0,    0,
+   48,   48,    0,   48,    0,   48,   48,    0,   48,  210,
+   48,    0,   48,    0,   48,   48,    0,   48,    0,   48,
+    0,    0,    0,    0,   48,    0,   48,   48,   48,   48,
+    0,   48,    0,    0,   48,    0,    0,    0,   48,    0,
+    0,   48,    0,    0,   48,    0,    0,  311,  442,   48,
+   48,    0,    0,   48,   48,   48,   48,   48,   48,   48,
+    0,    0,   48,    0,   48,    0,    0,    0,   48,    0,
+    0,  443,    0,    0,    0,    0,    0,    0,  442,   48,
+   48,   48,   48,   48,  444,   48,    0,    0,  445,  446,
+    0,    0,    0,    0,  447,    0,  448,  449,  450,  451,
+    0,  443,    0,    0,  452,    0,    0,    0,  453,   48,
+    0,    0,    0,    0,  444,    0,    0,    0,    0,  446,
+  454,    0,    0,  455,  447,  456,  448,  449,  450,  451,
+    0,    0,    0,    0,  452,    0,    0,    0,  453,    0,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,  457,
+  454,    0,    0,  455,    0,  456,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-    0,    0,  454,
+    0,    0,    0,    0,    0,    0,    0,    0,    0,  457,
   };
   protected static readonly short [] yyCheck = {            17,
-  295,   18,   17,  296,   17,    4,    6,  499,  105,   52,
-  188,  232,  501,  287,  456,   17,  187,  247,  475,  538,
-   17,  327,  324,  294,   20,  292,   85,  345,   60,  548,
-  156,   60,  889, 1057, 1093, 1094,  345,   48,  719,   88,
-   89,   78,  558,    0,   59,  314,  111,   60,  113,  320,
-  256,   64,  111,  268,  113,  256,   74,  234,  107,  256,
-   78, 1177,  268,  256,  268,   80,  256,   82,  256,  256,
-  256,   17,  276,  268,  256,  256,   94, 1193,  294,   17,
- 1139,  282,  256,   17,   17,  294,  256,  256, 1393, 1394,
-  306,  868,  256,  335,  256,  256,  256,  946,  256,   17,
-   17,   21,   17,  694,  695,  256,  256,  367,  256,  341,
-  277,  263,    0,  314,  281,   96,   97,   98,   99,  100,
-  101,  102,  103,  639,  367,  974,  372,  357,  399,  375,
-  367,   17,  257,   53,  264,   17,  368,  266,  156,   17,
-   17,  156,  339,  156, 1449,  188,  737,  344,  739,  346,
-  199,  200,  367,  294,  156,  352,  353,  339,  255,  156,
-  341,  294,  344,  315,  346,  306,  256,    6,  428, 1018,
-  352,  353,  256,  358,  417,  342,  256,  339,   17,  369,
-  366,  371,  368,  373,  370,  314,  428,  368,  339,  232,
-  294,  428,  380,  495,  971,  325,  973,  515,  358,  420,
-  297,  417,  256,  498,  366,  374,  421,  696,  417,  373,
-  156,  260,  223,  417,  343,  421,  417,    0,  156,  380,
-  368,   60,  156,  156,  417,   64,  421,  417,  228,  247,
-  417,  428,  538,  419,  252,   20,  422,  286,  156,  156,
-  558,  156,  548,  417,  421,  374,  428,  417, 1364,   88,
-   89,  348,  284,  302,  313,  284,  321,  390,  317,  417,
-  292,  390,  321,  423,  424,  425,  426,  417,  107,  287,
-  156,  284,  290,  291,  156, 1391,  256,  367,  156,  156,
-  413,  310,  366,  373,  413,  303,  390, 1403,  368, 1405,
-  308,  375,  310,  342,  309,  413,  314,  310,  427,  294,
-  257,  338,  420,   88,   89, 1138,    0,  325,  326,  413,
-  991,  256,  828,  256,  327,  369,  256,  156,  371,  373,
-  338,  639,  107, 1156,  847,  327,  335,  376,  377,  426,
-  327,  640,  263,  262, 1358,  858, 1206,  325,  325,  357,
-  358,  294,  660,  324,  362,  363,  364,  365,  366,  367,
-  368,  369,  370,  371,  372,  404,  405,  349,  350,  339,
-  199,  200,  953,  460,  461, 1424, 1236,  400,  256,  298,
-  859,  349,  350,  367, 1207,  428,  394,  420,  367,  412,
-  361,  838, 1441,  367,  315,  371,  366,  430,  485, 1246,
-  349,  350,  373,  374,  375,  390,  371,  378,  379,  380,
-  381,  382,  383,  384,  385,  386,  387,  388,  389,  390,
-  391,  392,  393,  682,  199,  200,  427,  428,  413,  367,
-  343,  260,  433,  368, 1257,  368,  422,  367, 1261,  417,
-  417,  698,  368,  373,  428,  371,  428,  390,  668,  428,
-  436,  257,  428,  761,  428,  284,  475,  286,  377,  378,
-  428,  339,  761,  428,  366,  470,  945,  296,  370, 1052,
-  413,  417,  475,  302,  371,  371,  373,  390,  565,  428,
-  567,  310,  569,  375,  257,  260,  272, 1068,  366,  497,
-  428,  499,  370,  501,  372,  373,  374,  375,  327,  272,
-  413,  375,  380,  367,  277,  368,  511,  512,  281,  372,
-  296,  286,  305,  342,  427,  523,  345,  419, 1099, 1100,
-  828,  296,  530,  296,  495, 1106,  373,  302,  827,  515,
-  372,  428,  428,  375,  357,  538,  428,  323,  269,  371,
-  825,  373,  547,   60,  631,  548,  538,  376,  377,  370,
-  323,  538,  305,  417,  428,  286,  548,  371,  778,  422,
-  852,  548,  385,  571,  572,  256, 1161,  342,  415,  342,
-  345,  368, 1019,  257,  375,  404,  405,  261,  837,   96,
-   97,   98,   99,  100,  101,  102,  103,  256,  272,  343,
-  375,  707,  563,  277, 1103,  856,  428,  281,  419,  256,
-  284,  376,  377,  417, 1160, 1161,  889,  256,  368, 1204,
-  618, 1206,  296,  297,  305,  702,  624,  301,  302,  272,
-  374,  272,  380,  307, 1180,  309,  310,  311,  312,  404,
-  405,  306,  390,  317,  417,  375,  390,  321,  313,  323,
-  390, 1236,  370,  296,  427,  296,  475,  422, 1204,  333,
- 1206,  357,  336,  366,  338,  413,  305,  417,  342,  413,
-  668,  436,  368,  413,  385,  371,  372,  373,  373,  427,
-  323,  661,  323,  427,  682,  359,  698,  962,  368,  385,
- 1236,  730,  339,  691,  723,  370,  515,  344,  696,  346,
-  417,  694,  695,  701,  914,  352,  353,  366,  417,  368,
-  427,  370,  371,  383,  373,  744,  375,  343,   62,  538,
-  415,  417,   66,   67,   68, 1298,   70,   71,  757,  548,
-  725,   75,   76,  370,  357,  372,  378,  417,   82,  558,
-   84,  399,   86,  741,  737,  743,  739,   91,   92,  372,
-  515,  413, 1325, 1326,  380, 1328,  388,  755,  417,  384,
-  419,  357,  385,  422,  390,  427, 1339,  389,  112, 1342,
- 1343, 1025,  368, 1161,  368,  773,  372,  284,  339,  802,
-  778,  779, 1057,  781, 1357,  292, 1072,  413,  369,  385,
-  367,  868,  373,  558,  792,  793,  373,  339,  417,  390,
-  829,  427,  344,  380,  346,  366, 1060,  349,  350,  413,
-  352,  353, 1161,  343,  375,  256, 1204, 1103, 1206,  339,
-  639,  417,  413,  427,  344,  823,  346,  825,  269,  349,
-  350,  373,  352,  353,  810,  815,  427,  366,  989,  837,
- 1050,  660,  840, 1097,  374,  286,  375, 1133, 1236,  847,
-  380,  397,  398,  373,  361, 1204, 1278, 1206, 1161,  857,
-  390,  859, 1161,  380,  361,  357,  373,  374,  375,  390,
-  366,  378,  379,  390,  639,  694,  695, 1346, 1161,  375,
-  372,  378,  379,  413,  369,  370,  428, 1236,  373,  372,
-  919,  852,  413,  385,  971,  660,  413,  427,  896,  420,
-  898, 1204,  900, 1206,  723, 1204,  375, 1206,  428,  417,
-  254, 1112,  256,  366, 1168,  992,  914, 1215,  737,  368,
-  739, 1204,  375, 1206, 1222,  744, 1161, 1161,  370,  357,
- 1088,  380,  371, 1236,  373,  911,  375, 1236,  757, 1408,
-  366,  921,  761,  923,  372,  925,  366,  945,  369,  375,
-  294,  414,  373, 1236,  339,  375,  417,  385,  723,  344,
-  953,  346,  306,  357,  349,  350,  256,  352,  353, 1204,
- 1204, 1206, 1206, 1246,  368, 1444,  306,  371,  372,  744,
-  370,  976,  372,  313,  370,  983,  372,  985,  366,  987,
-  417,  385,  757, 1465, 1466,  325,  761,  375,  366,  272,
-  368, 1236, 1236,  417,  277,  391,  392,  339,  281,  828,
-  829,  371,  344,  373,  346,  375,  340,  349,  350,  998,
-  352,  353,  306,  296,  308,  411,  369, 1025,  366,  313,
-  373,  393,  394,  419,  381,  382,  422,  375, 1265, 1037,
- 1038,  325,  369,  428, 1271,  810,  373, 1045,  395,  396,
-  323, 1278, 1050,  373, 1051,  375,  563,  369,  375, 1057,
-  380,  373, 1060,  828,  829, 1088,  375, 1090,  369,  342,
-  889,  339,  373,  371,  366, 1068,  344,  375,  346, 1072,
- 1078,  349,  350, 1358,  352,  353,  371, 1085,  373, 1112,
- 1072,  382,  383,  384,  385, 1072,  428,  372,  367, 1097,
-  919,  370,  417,  372,  373,  375, 1099, 1100,  354,  355,
- 1103, 1109, 1110, 1106,  369,  371,  371,  373,  373, 1142,
-  417, 1103,  391,  392,  889,  375, 1103,  471,  369,  370,
- 1159,  372,  373,  374,  953,  354,  355, 1160, 1161,  369,
- 1133,  371,  411,  373,  349,  350,  911,  385,  386,  387,
-  419, 1133, 1150,  422,  919,  366, 1133, 1180,  375,  370,
-  428,  372,  373,  373,  375,  375,  339,  511, 1166,  380,
- 1168,  344,  367,  346,  373,  370,  375,  372,  373,  352,
-  353, 1204,  369, 1206,  371, 1214,  366,  369,  371,  371,
-  370,  698,  372,  373,  417,  375,  391,  392, 1275,  369,
-  380,  371,  369,  414,  371,  371,  371,  373,  373,  413,
-    0, 1288,  368, 1236, 1243, 1244,  411,  369,  369,  371,
-  371,  413,  414, 1218,  419,  363,  364,  422, 1305,  417,
- 1307,  256,  417,  373,  414,  375,  371,  372, 1267,  264,
-  265, 1270,  267,  363,  364,  270,  271, 1055, 1056, 1068,
-  275,  276,  277, 1072,  279,  366,  373,  417,  375,  370,
-  285,  372,  373,  288,  375,  373,  373,  375,  375,  380,
-  295,  371, 1091,  386,  387,  300,  371,  302,  303,  304,
- 1099, 1100,  380,  381, 1103,  417,  375, 1106, 1283,  371,
-  371,  316,  367,  318,  319,  373,  417,  322,  371,  371,
-  325,  371,  327,  371,  329,  330,  331,  332,  371,  334,
-  294,  294,  373, 1336, 1133,  371,  371,  375,  417,  373,
-  370,  256,  371,  256, 1143,  373, 1091,  374,  380,  380,
- 1353,  417,  417,  356,  371,  360,  361,  362,  373,  373,
- 1159,  374,  372, 1366, 1367,  370,  417,  371, 1346, 1344,
-  401,  402,  403,  404,  405,  406,  407,  408,  409,  410,
- 1358,  380,  373,  373,  373,  294,  373,  375,  428,  422,
- 1393, 1394,  417,  371,  373,  366,  417, 1375, 1143,    0,
-  372,  371,  343,  294,  373,  417,  294,  373,  417,  417,
-  369,  416,  417,  370, 1159, 1214, 1215,  417,  366,  374,
-  256,  256,  373, 1222,  339,  256,  256,  371,  380,  344,
- 1408,  346,  347,  348,  349,  350,  351,  352,  353,  354,
-  355,  356,  371,  280, 1243, 1244, 1449, 1246,  256,  366,
-  417,  367,  367,  371,  369,  417,  371,  417,  373,  374,
-  375,  417,  369,  375,  370,  375, 1444,  417, 1267, 1214,
- 1215, 1270,  373,  373,  389, 1450, 1451, 1222,  375,  375,
-  369,  371, 1457, 1458,  399,  400,  256, 1465, 1466,  371,
-  420,  261,  262,  380,  422,  347,  351,  412, 1243, 1244,
-  366, 1246,  380,  380,  256,  256,  371, 1252,  367,  371,
-  373,  369,  366,  428,  284,  347,  369,  374,  374,  348,
- 1265,  371, 1267,  369,  294, 1270, 1271,  297,  298,  371,
-  373,  417,  302, 1278,  367,  305,  417,  307,  339,  309,
-  310,  311,  312,  348,  367,  373,  366,  317,  375,  374,
-  366,  321,  366,  356,  367,  325,  380,  375,  370,  337,
-  367,  367,  373,  333,  305,    0,  336,  371,  338,  339,
-  417,  367,  417,  417,  344,  370,  346,  347,  348,  349,
-  350,  351,  352,  353,  354,  355,  356,  370,  368,  359,
-  366,  417,  380,  370,  375,  417,  366,  367,  417,  369,
-  370,  371,  372,  373,  374,  375,  370,  377,  378,  370,
-  380,  381,  382,  383,  384,  385,  386,  387,  388,  389,
-  370,  391,  392,  393,  394,  395,  396,  397,  398,  399,
-  400,  401,  402,  403,  404,  405,  406,  407,  408,  409,
-  410,  411,  412,  372,  370,  415,  366,  417,  370,  419,
-  380,  368,  422,  371,  373,  256,  257,  371,  428,  372,
-  372,  256,  373,  264,  265,  266,  267,  268,  373,  270,
-  271,  373,  273,  274,  275,  276,  277,  278,  279,  280,
-  417,  375,  371,  371,  285,  369,  287,  288,  289,  290,
-  291,  292,  417,    0,  295,  375,  417,  375,  299,  300,
-  371,  302,  303,  304,  371,  375,  371,  417,  380,  366,
-  371,  367,  380,  314,  369,  316,  367,  318,  319,  315,
-  263,  322,  370,  324,  325,  326,  327,  328,  329,  330,
-  331,  332,  333,  334,  335,  370,  337,  367,  371,  340,
-  341,    0,  371,  344,  345,    0,  366,  375,  417,  375,
-  367,    0,  371,  375,  367,  371,  371,  417,  369,  360,
-  361,  362,  366,  375,  367,  366,  367,  367,  375,  370,
-  417,  369,  371,  366,  375,  376,  377,  378,  379,  417,
-  367,  375,  383,  375,  385,  371,  375,  371,  367,  371,
-  391,  392,  367,  371,  366,  375,  367,  367,  366,  372,
-  315,  375,  263,   51,   12,   52,  375,    5,  375,  375,
-  375,  375,  375,  375,  810,  416,  417,  418,  419,  911,
-  421,  256,  257, 1050, 1180, 1050, 1236,  428, 1398,  264,
-  265,  266,  267,  268, 1361,  270,  271, 1414,  273,  274,
-  275,  276,  277,  278,  279,    0, 1349, 1378, 1344, 1252,
-  285,  660,  287,  288,  289,  290,  291,  292,  831,  674,
-  295, 1265, 1458,  831,  299,  300,  831,  302,  303,  304,
- 1204, 1284, 1192,  827, 1452, 1367, 1371, 1366, 1451,  314,
- 1142,  316, 1307,  318,  319, 1252, 1143,  322,  802,  324,
+   17,    4,   17,   17,  298,  297,    6,  502,   18,   52,
+  504,  190,   20,   88,   89,  289,  459,  234,  189,  249,
+   60,  541,   85,  158,  330,  326,  296,   60,  478,  316,
+  294,  551,  892,  108, 1060,  348,  722,  561,  697,  698,
+   78,   17,    0,   17,   59,  236,  348,  294,  268,  112,
+  106,  114,  322,  112,   60,  114,   74,  256,  256,  256,
+   78, 1096, 1097,  256,  268,   80,  256,   82,  256,  256,
+   17,  256,  372,  256,   17,  256,  256,   95,   48,  335,
+  268,  740,  256,  742,  368,  368, 1180,   93,  294,  368,
+  343,   97,   98,   99,  100,  101,  102,  103,  104,  256,
+  256,  282, 1196,  256,  256,  376,   17, 1142,  268,  256,
+  256,  374, 1209,   60,  256,  256,  276,   64,  642,  264,
+  370,  371,   17, 1055,  374,  368,  201,  202,  381,  429,
+  360,   17,  402,  314,  257,   17,   17,   17,  391,  418,
+  158,  158, 1239,  158,  158,  429,  429,  190,  368,  339,
+   17,  358,  339,  416,  344,  256,  346,  344,  429,  346,
+   17,  414,  352,  353,  325,  352,  353,    6,  367,  294,
+  367,  418,  369,  429,  371,  428,  256,  376,   17,  257,
+  325,  306,  158,  381,  158,  391,  429,  262,  381,  374,
+   62,  234,  375,  339,   66,   67,   68,  498,   70,   71,
+    0,  257,  422,   75,   76,  699,  423,  256,  414,  501,
+   82,  158,   84,  288,   86,  158,  518,  358,  422,   91,
+   92,   60,  369,  420,  294,   64,  423,  335,  370,  304,
+  230,  249,  374,  424,  422,  541,  254,  418,  418,  429,
+  341,  113,  429,  299,  418,  551,  286,  158,  325,   88,
+   89,    0,  315,  286,  294,  225,  319,  418,  418,  561,
+  323,  418,  418,  158,  323,  418,  418,  294,  369,  108,
+  345,  289,  158, 1367,  292,  293,  158,  158,  158,  312,
+  286,  256,  263,  424,  425,  426,  427,  305,  294,  369,
+  341,  158,  310,  418,  312,  351,  311,  956,  316,  257,
+ 1394,  158,  256,  341,  379,  380,  294,  831,  994,  327,
+  328,  418, 1406,  330, 1408,  256,  330,  414,  369,  158,
+  369,  391,  256,  341,  349,  350,  305,  368,  256,  269,
+  643,  428,  407,  408,  315, 1361,  372,   20,  374,  286,
+  642,  418,  360,  361,  414,  305,  286,  365,  366,  367,
+  368,  369,  370,  371,  372,  373,  374,  375,  364,  262,
+ 1141,  663,  201,  202,  391,  312,  871,  263,  862, 1301,
+  376,  377,  378,  429,  368,  381,  382,  277, 1159,  397,
+  423,  281,  343,  330,  256,  368,  258,  414,  429, 1249,
+  433,  841, 1427,  429,  369,  298, 1328, 1329,  685, 1331,
+  349,  350,  256,  391,  429,   88,   89,  463,  464, 1444,
+ 1342,  339, 1071, 1345, 1346,  306,  370,  425,  372,  315,
+  374,  372,  313,  262,  296,  108,  414,  368, 1360, 1210,
+  391,  439,  488,  374,  368,  429,  308,  701,  369,  367,
+  374,  671,  342, 1102, 1103,  478,  429,  286,  372,  288,
+ 1109,  764,  371,  414,  948, 1396, 1397,  257,  473,  298,
+  430,  431,  764,  372,  418,  304,  436,  428,  372,  974,
+  374,  976,  272,  312,  357,  378,  379,  277,  429, 1260,
+  429,  281,  500, 1264,  502,  339,  504,  349,  350,  376,
+  367,  330,  376,  949,  371,  371,  296,  373,  369,  514,
+  515, 1164,  373,  386,  272,  429,  345,  256,  526,  348,
+  518, 1452,  568,  367,  570,  533,  572,  830,  201,  202,
+  429,  977,  850,  323,  541,  429,  343,  541,  296,  831,
+  371,  478,  373,  861,  551,  550,  828,  551, 1164,  256,
+  379,  380,  342,  420, 1207,  429, 1209,  256,  343,  272,
+  371,  781,  423,  840,  855,  323,  574,  575,  375,  266,
+  566,  272, 1163, 1164,  381, 1021,  277,  429,  407,  408,
+  281, 1164, 1022,  296,  391,  710, 1239,  272,  634,  262,
+  375, 1207, 1183, 1209,  368,  296, 1106,  391,   21,  859,
+  339,  256,  256,  367,  541,  369,  391,  414,  892,  420,
+  323,  296,  474,  621,  551,  288, 1207,  314, 1209,  627,
+  414,  428,  323, 1239, 1207,  298, 1209,  369,  367,  414,
+   53,  304,  371,  376,  373,  374,  375,  376,  323,  372,
+  339,  342,  381,  428,  418,  344,  343,  346, 1239,  478,
+  305,  305,  514,  352,  353, 1164, 1239,  374, 1164,  705,
+  367,  726,  369,  671,  371,  372,  369,  374,  376,  376,
+  414,  701,  345,  367,  664,  348,  418,  685,  375,  371,
+  733,  391,  747,  965,  428,  418,  694,  418,  371,  518,
+  373,  699,  394,  395,  391,  760,  704,  917, 1207,  416,
+ 1209, 1207, 1164, 1209,  414,  701,  379,  380, 1164,  392,
+  393,  418,  541,  420,  339,  418,  423,  414,  428,  344,
+ 1164,  346,  551,  728,  349,  350,  256,  352,  353,  412,
+ 1239,  428,  561, 1239,  407,  408,  744,  420,  746,  269,
+  423,  357,  368,  339,  418, 1207,  357, 1209,  374,  374,
+  758, 1207,  425, 1209,  428,  381,  286,  373,  369,  381,
+  697,  698,  373, 1207, 1028, 1209,  439,  832,  776,  391,
+  386,  367,  805,  781,  782,  386,  784, 1239, 1060, 1075,
+  376,  418,  357, 1239,  256,  357,  381,  795,  796,  398,
+  399,  428,  414,  357,  391, 1239,  391,  369,  373, 1063,
+  372,  373,  374,  740,  429,  742,  428,  418,  370,  373,
+ 1106,  386,  374,  642,  386,  813,  339,  414,  826,  414,
+  828,  344,  386,  346,  421,  871,  349,  350,  818,  352,
+  353,  992,  840, 1053,  663,  843, 1100,  372,  367,  374,
+ 1136,  376,  850,  306,  357,  518,  418,  376, 1281,  401,
+  313,  374,  860,  364,  862,  367,  369,  922,  386,  372,
+  373,  413,  325,  373,  376, 1349,  376,  339,  697,  698,
+  381,  382,  344,  386,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,  367, 1268,  373,  561,  294,
+  376,  899, 1274,  901,  376,  903,  368,  726,  370, 1281,
+  372,  306,  374,  375,  376,  367,  429, 1171, 1115,  917,
+  339,  740,  414,  742,  376,  344,  914,  346,  747,  421,
+  349,  350, 1091,  352,  353,  369, 1218, 1411,  974,  369,
+  367,  760,  372, 1225,  924,  764,  926,  381,  928,  376,
+  948,  339,  372,  306,  374,  308,  344,  256,  346,  995,
+  313,  349,  350,  379,  352,  353,  265,  429,  267,  367,
+  384,  270,  325, 1447,  367, 1249,  275,  389,  376,  642,
+  279,  370,  372,  376,  979,  374,  376,  370,  986,  288,
+  988,  374,  990, 1468, 1469,  374,  295,  376,  385,  370,
+  663,  300,  381,  374,  370,  304,  382,  383,  374,  400,
+  429,  370,  831,  832,  372,  374,  374,  316, 1001,  318,
+  396,  397,  372,  322,  374,  374,  376,  376,  390,  956,
+ 1028,  330,  331,  256,  370,  334,  372,  374,  337,  376,
+  418,  429, 1040, 1041,  373,  370,  339,  372,    0,  374,
+ 1048,  344,  370,  346,  372, 1053,  349,  350,  369,  352,
+  353,  376, 1060,  726, 1054, 1063,  418,  370, 1091,  372,
+ 1093,  374,  339,  892,  386,  387,  388,  344, 1075,  346,
+  370, 1075,  372, 1081,  747,  352,  353,  414,  415, 1361,
+ 1088,  370, 1115,  372,  371,  370,  371,  760,  373,  374,
+  375,  764, 1100,  922,  367,  256,  415, 1162,  371, 1106,
+  373,  374, 1106,  376, 1112, 1113,  339,  418,  381,  418,
+  256,  344, 1145,  346,  347,  348,  349,  350,  351,  352,
+  353,  354,  355,  356,  354,  355,  429,  956,  418, 1136,
+ 1163, 1164, 1136,  340, 1071,  368,  418,  370, 1075,  372,
+  813,  374,  375,  376,  376, 1153,  385,  386,  387,  388,
+ 1183,  372, 1217,  374,  372,  418,  374,  390,  831,  832,
+  370, 1169,  372, 1171,  376, 1102, 1103,  400,  401, 1106,
+  373,  370, 1109,  372, 1207,  367, 1209,  374,  339,  376,
+  413, 1246, 1247,  344,  418,  346,  347,  348,  349,  350,
+  351,  352,  353,  354,  355,  356,  429,  376,  374, 1136,
+  376,  374,  374,  376,  376, 1270, 1239,  368, 1273,  370,
+  376,  372,  376,  374,  375,  376, 1221,  364,  365,  892,
+  372,   97,   98,   99,  100,  101,  102,  103,  104,  390,
+  414,  368, 1278,  418,  371,  418,  373,  374,  418,  400,
+  401,  914, 1071,  418,  367, 1291, 1075,  369,  371,  922,
+  373,  374,  413,  376,  372,  392,  393,  372,  381,  354,
+  355,  418, 1308,  376, 1310, 1094,  372,  373,  429,  349,
+  350,  364,  365, 1102, 1103,  412,  372, 1106, 1058, 1059,
+ 1109, 1286,  372,  420,  367,  418,  423,  368,  371,  374,
+  373,  374,  415,  376,  372,  257,  383,  384,  381,  261,
+  389,  390,  372,  372,  372,  372, 1339, 1136,  294,  294,
+  272,  374,  372,  372,  376,  277,  418, 1146,  374,  281,
+  372,  371,  284, 1356,  256,  374,  418,    0,  375,  356,
+  418,  372,  415, 1162,  296,  297, 1369, 1370,  381,  301,
+  302, 1349, 1347,  374,  374,  307,  375,  309,  310,  311,
+  312,  373,  418, 1361,  372,  317,  381,  374,  374,  321,
+  374,  323,  374, 1396, 1397,  418,  376,  294,  429,  423,
+ 1378,  333,  372,  335,  336,  374,  338,  367,  418,  372,
+  342,  373,  418,  343,  294,  374,  294,  374, 1217, 1218,
+  418,  370,  418,  371,  418,  367, 1225,  256,  375,  256,
+  362,  381,  256, 1411,  374,  256,  368,  369,  372,  372,
+  368,  280,  381,  371,  256,  373,  374, 1246, 1247, 1452,
+ 1249, 1094,  402,  403,  404,  405,  406,  407,  408,  409,
+  410,  411,  367,  372,  392,  393,  418,  368,  376, 1447,
+  370, 1270,  418,  256, 1273,  418,  371,  418, 1453, 1454,
+  326,  418,  376,  374,  412, 1460, 1461,  374,  376,  370,
+ 1468, 1469,  420,  376,  421,  423,  372,  372,  423,  381,
+  347,  351,  367, 1146,  381,  256,  256,  381,  372,  368,
+  372,  347,  370,  374,  370,  375,  367,  372,  364, 1162,
+  372,  375,  370,  348,  368,    0,  418,  376,  418,  374,
+  376,  377,  378,  374,  339,  381,  382,  383,  384,  385,
+  386,  387,  388,  389,  390,  391,  392,  393,  394,  395,
+  396,  348,  368,  375,  367,  381,  339,  367,  367,  376,
+  368,  344,  356,  346,  347,  348,  349,  350,  351,  352,
+  353,  354,  355,  356, 1217, 1218,  371,  368,  374,  368,
+  418,  368, 1225,  337,  372,  368,  305,  370,  418,  372,
+  418,  374,  375,  376,  371,  418,  371,  369,  418,  367,
+  418,  371,  376, 1246, 1247,  371, 1249,  390,  371,  371,
+  381,  371, 1255,  256,  373,  367,  371,  381,  261,  262,
+  369,  374,  256,  370,  372, 1268,  372, 1270,  373,  373,
+ 1273, 1274,  374,  374,  374,  372,  418,  376, 1281,  372,
+  418,  284,  376,  372,  376,  418,  429,  372,  376,  418,
+  372,  294,  498,  367,  297,  298,  372,  381,  368,  302,
+  381,  370,  305,  368,  307,  315,  309,  310,  311,  312,
+  263,  371,  371,  368,  317,  372,  372,    0,  321,    0,
+  367,  372,  325,  376,  376,  368,    0,  418,  376,  368,
+  333,  372,    0,  336,  372,  338,  339,  370,  418,  367,
+  376,  344,  368,  346,  347,  348,  349,  350,  351,  352,
+  353,  354,  355,  356,  368,  372,  376,  370,  367,  362,
+  566,  376,  368,  368,  367,  368,  368,  370,  371,  372,
+  373,  374,  375,  376,  418,  378,  379,  376,  381,  382,
+  383,  384,  385,  386,  387,  388,  389,  390,  418,  392,
+  393,  394,  395,  396,  397,  398,  399,  400,  401,  402,
+  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,
+  413,  372,  376,  416,  372,  418,  372,  420,  367,  376,
+  423,  256,  257,  368,  368,  367,  429,  373,  376,  264,
+  265,  266,  267,  268,  315,  270,  271,  376,  273,  274,
+  275,  276,  277,  278,  279,  280,  376,  376,  376,  376,
+  285,  376,  287,  288,  289,  290,  291,  292,  376,  263,
+  295,    0,   51,   12,  299,  300,   52,  302,  303,  304,
+    5, 1053,  914, 1053,  813, 1183, 1239, 1401, 1364,  314,
+ 1417,  316, 1352,  318,  319, 1381, 1347,  322,  663,  324,
   325,  326,  327,  328,  329,  330,  331,  332,  333,  334,
-  335,  515,  337,  852,  701,  340,  341,  778,  572,  344,
-  345,  357,  773,  668,   72,  962,  698,  388,  390,  389,
-  393,  761,  391, 1214,  392,  360,  361,  362, 1126, 1133,
-  976,  366,  367, 1072,  156,  370,  947,  932, 1028, 1038,
-  375,  376,  377,  378,  379, 1030, 1019,  894,  383,  256,
-  385,  872,  513,  412,  261,  262,  391,  392, 1210, 1110,
-  808,   -1,   -1,   -1,   -1,   -1,  807,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,    0,   -1,   -1,  284,   -1,   -1,
-   -1,  416,  417,  418,  419,   -1,  421,  294,   -1,   -1,
-  297,  298,   -1,  428,   -1,  302,   -1,   -1,  305,   -1,
-  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,   -1,
-  317,   -1,   -1,   -1,  321,   -1,   -1,   -1,  325,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,
-   -1,  338,  339,   -1,   -1,   -1,   -1,  344,   -1,  346,
-  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
-  357,   -1,  359,   -1,   -1,   -1,   -1,   -1,   -1,  366,
-  367,  368,  369,  370,  371,  372,  373,  374,  375,   -1,
-  377,  378,   -1,   -1,  381,  382,  383,  384,  385,   -1,
-   -1,  388,  389,   -1,   -1,   -1,  393,  394,  395,  396,
-  397,  398,  399,  400,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  256,   -1,    0,   -1,  412,  261,  262,  415,   -1,
-  417,   -1,  419,   -1,   -1,  422,   -1,   -1,   -1,   -1,
-   -1,  428,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  284,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  294,
-   -1,   -1,  297,  298,   -1,   -1,   -1,  302,   -1,   -1,
-  305,   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,
-   -1,   -1,  317,   -1,   -1,   -1,  321,   -1,   -1,   -1,
-  325,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,
-   -1,  336,   -1,  338,  339,   -1,   -1,   -1,   -1,  344,
-   -1,  346,  347,  348,  349,  350,  351,  352,  353,  354,
-  355,  356,   -1,   -1,  359,   -1,   -1,   -1,   -1,   -1,
-   -1,  366,  367,  368,  369,  370,  371,   -1,  373,  374,
-  375,   -1,  377,  378,   -1,   -1,  381,  382,  383,  384,
-  256,   -1,    0,  388,  389,  261,  262,   -1,  393,  394,
-  395,  396,  397,  398,  399,  400,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  412,  284,   -1,
-  415,   -1,  417,   -1,  419,   -1,   -1,  422,  294,   -1,
-   -1,  297,  298,  428,   -1,   -1,  302,   -1,   -1,  305,
+  335,  834,  337,  834, 1255,  340,  341,  834, 1461,  344,
+  345,  677,  830, 1268, 1287, 1195, 1207, 1455, 1374, 1370,
+ 1369, 1454, 1145, 1310,  359,  360,  361,  805,  363, 1255,
+  518,  855,  367,  368,  360, 1146,  371,  704,  575,   72,
+  701,  376,  377,  378,  379,  380,  776,   93,  781,  384,
+  671,  386,  391,  965,  392,  395,  393,  392,  393, 1129,
+  394,  764, 1136,  396, 1217,  979,  158, 1075, 1041,  950,
+  935,  897, 1031, 1033,  415, 1022,  516,  875, 1213, 1113,
+  811,  810,  417,  418,  419,  420,   -1,  422,  256,  257,
+   -1,   -1,   -1,   -1,  429,   -1,  264,  265,  266,  267,
+  268,   -1,  270,  271,   -1,  273,  274,  275,  276,  277,
+  278,  279,   -1,   -1,    0,   -1,   -1,  285,   -1,  287,
+  288,  289,  290,  291,  292,   -1,   -1,  295,   -1,   -1,
+   -1,  299,  300,   -1,  302,  303,  304,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  314,   -1,  316,  855,
+  318,  319,   -1,   -1,  322,   -1,  324,  325,  326,  327,
+  328,  329,  330,  331,  332,  333,  334,  335,   -1,  337,
+   -1,   -1,  340,  341,   -1,   -1,  344,  345,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,  367,
+  368,   -1,   -1,  371,   -1,   -1,   -1,   -1,  376,  377,
+  378,  379,  380,   -1,   -1,   -1,  384,  256,  386,   -1,
+   -1,   -1,  261,  262,  392,  393,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,    0,  284,   -1,   -1,   -1,  417,
+  418,  419,  420,   -1,  422,  294,   -1,   -1,  297,  298,
+   -1,  429,   -1,  302,   -1,   -1,  305,   -1,  307,   -1,
+  309,  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,
+   -1,   -1,  321,   -1,   -1,   -1,  325,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,  338,
+  339,   -1,   -1,   -1,   -1,  344,   -1,  346,  347,  348,
+  349,  350,  351,  352,  353,  354,  355,  356,  357,   -1,
+   -1,   -1,   -1,  362,   -1,   -1,   -1,   -1,  367,  368,
+  369,  370,  371,  372,  373,  374,  375,  376,   -1,  378,
+  379,   -1,   -1,  382,  383,  384,  385,  386,   -1,   -1,
+  389,  390,   -1,   -1,   -1,  394,  395,  396,  397,  398,
+  399,  400,  401,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  256,   -1,   -1,   -1,  413,  261,  262,  416,   -1,  418,
+   -1,  420,   -1,   -1,  423,   -1,   -1,   -1,   -1,   -1,
+  429,    0,   -1,   -1,   -1,   -1,   -1,   -1,  284,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  294,   -1,
+   -1,  297,  298,   -1,   -1,   -1,  302,   -1,   -1,  305,
    -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,
    -1,  317,   -1,   -1,   -1,  321,   -1,   -1,   -1,  325,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,
   336,   -1,  338,  339,   -1,   -1,   -1,   -1,  344,   -1,
   346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
-  356,   -1,   -1,  359,   -1,   -1,   -1,   -1,   -1,   -1,
-  366,  367,  368,  369,  370,  371,   -1,  373,  374,  375,
-   -1,  377,  378,   -1,   -1,  381,  382,  383,  384,  256,
-   -1,   -1,  388,  389,  261,  262,   -1,  393,  394,  395,
-  396,  397,  398,  399,  400,   -1,   -1,    0,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  412,  284,   -1,  415,
-   -1,  417,   -1,  419,   -1,   -1,  422,  294,   -1,   -1,
-  297,  298,  428,   -1,   -1,  302,   -1,   -1,  305,   -1,
-  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,   -1,
-  317,   -1,   -1,   -1,  321,   -1,   -1,   -1,  325,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,
-   -1,  338,  339,   -1,   -1,   -1,   -1,  344,  285,  346,
-  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
-   -1,   -1,  359,   -1,   -1,   -1,   -1,   -1,   -1,  366,
-  367,   -1,  369,  370,  371,   -1,  373,  374,  375,   -1,
-  377,  378,   -1,   -1,  381,  382,  383,  384,  256,   -1,
-  327,  388,  389,   -1,  262,   -1,  393,  394,  395,  396,
-  397,  398,  399,  400,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  412,   -1,   -1,  415,   -1,
-  417,   -1,   -1,   -1,   -1,   -1,  294,   -1,   -1,   -1,
-  298,  428,   -1,   -1,    0,   -1,   -1,   -1,   -1,  376,
-  377,  378,  379,   -1,  381,  382,  383,  384,  385,  386,
-  387,  388,   -1,   -1,  391,  392,  393,  394,  395,  396,
-  397,  398,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  339,   -1,   -1,   -1,   -1,  344,   -1,  346,  347,
-  348,  349,  350,  351,  352,  353,  354,  355,  356,  357,
-  256,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  366,  367,
-  368,  369,  370,  371,  372,  373,  374,  375,   -1,  377,
-  378,   -1,   -1,  381,  382,  383,  384,  385,   -1,   -1,
-  388,  389,   -1,   -1,   -1,  393,  394,  395,  396,  397,
-  398,  399,  400,  256,   -1,   -1,   -1,   -1,   -1,  262,
-   -1,   -1,   -1,   -1,  412,   -1,    0,  415,   -1,  417,
-   -1,  419,   -1,   -1,  422,   -1,   -1,   -1,   -1,   -1,
-  428,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  294,   -1,  339,   -1,  298,   -1,   -1,  344,   -1,
+  356,   -1,   -1,   -1,   -1,   -1,  362,   -1,   -1,   -1,
+   -1,  367,  368,  369,  370,  371,  372,   -1,  374,  375,
+  376,   -1,  378,  379,   -1,   -1,  382,  383,  384,  385,
+  256,   -1,   -1,  389,  390,  261,  262,   -1,  394,  395,
+  396,  397,  398,  399,  400,  401,    0,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  413,  284,   -1,
+  416,   -1,  418,   -1,  420,   -1,   -1,  423,  294,   -1,
+   -1,  297,  298,  429,   -1,   -1,  302,   -1,   -1,  305,
+   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,
+   -1,  317,   -1,   -1,   -1,  321,   -1,   -1,   -1,  325,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,
+  336,   -1,  338,  339,   -1,   -1,   -1,   -1,  344,   -1,
   346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
-  356,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  367,   -1,  369,   -1,  371,   -1,  373,  374,  375,
-   -1,   -1,   -1,   -1,    0,   -1,  339,   -1,   -1,   -1,
-   -1,  344,   -1,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  366,  367,   -1,  369,  370,  371,   -1,
-  373,  374,  375,   -1,  377,  378,   -1,   -1,  381,  382,
-  383,  384,  428,   -1,   -1,  388,  389,   -1,   -1,   -1,
-  393,  394,  395,  396,  397,  398,  399,  400,   -1,   -1,
-   -1,   -1,   -1,    0,   -1,   -1,   -1,   -1,   -1,  412,
-   -1,  257,  415,   -1,  417,  261,   -1,  263,   -1,  265,
-   -1,  267,   -1,   -1,  270,  428,  272,  273,   -1,  275,
-   -1,  277,   -1,  279,   -1,  281,  282,  283,  284,   -1,
-   -1,  287,  288,   -1,   -1,   -1,    0,  293,  294,  295,
-  296,  297,   -1,   -1,  300,  301,  302,   -1,  304,   -1,
-  306,  307,  308,  309,  310,  311,  312,  313,   -1,  315,
-  316,  317,  318,   -1,   -1,  321,  322,  323,   -1,  325,
-   -1,   -1,   -1,   -1,  330,  331,   -1,  333,  334,    0,
-  336,  337,  338,   -1,   -1,   -1,  342,   -1,   -1,   -1,
+  356,   -1,   -1,   -1,   -1,   -1,  362,   -1,   -1,   -1,
+   -1,  367,  368,  369,  370,  371,  372,   -1,  374,  375,
+  376,   -1,  378,  379,   -1,   -1,  382,  383,  384,  385,
+   -1,   -1,   -1,  389,  390,   -1,   -1,   -1,  394,  395,
+  396,  397,  398,  399,  400,  401,   -1,  256,   -1,   -1,
+   -1,   -1,  261,  262,   -1,   -1,   -1,  413,   -1,   -1,
+  416,   -1,  418,    0,  420,   -1,   -1,  423,   -1,   -1,
+   -1,   -1,   -1,  429,   -1,  284,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  294,   -1,   -1,  297,  298,
+   -1,   -1,   -1,  302,   -1,   -1,  305,   -1,  307,   -1,
+  309,  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,
+   -1,   -1,  321,   -1,   -1,   -1,  325,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,  338,
+  339,   -1,   -1,   -1,  256,  344,   -1,  346,  347,  348,
+  349,  350,  351,  352,  353,  354,  355,  356,   -1,   -1,
+   -1,   -1,   -1,  362,   -1,   -1,   -1,   -1,  367,  368,
+   -1,  370,  371,  372,   -1,  374,  375,  376,   -1,  378,
+  379,   -1,  256,  382,  383,  384,  385,   -1,  262,   -1,
+  389,  390,   -1,   -1,   -1,  394,  395,  396,  397,  398,
+  399,  400,  401,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  413,   -1,   -1,  416,   -1,  418,
+  294,   -1,   -1,   -1,  298,   -1,   -1,  339,   -1,   -1,
+  429,    0,  344,   -1,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  262,   -1,   -1,  368,   -1,  370,   -1,
+  372,   -1,  374,  375,  376,  339,   -1,   -1,   -1,   -1,
+  344,   -1,  346,  347,  348,  349,  350,  351,  352,  353,
+  354,  355,  356,  357,   -1,   -1,   -1,   -1,   -1,  298,
+   -1,   -1,   -1,  367,  368,  369,  370,  371,  372,  373,
+  374,  375,  376,   -1,  378,  379,   -1,   -1,  382,  383,
+  384,  385,  386,   -1,   -1,  389,  390,  429,   -1,   -1,
+  394,  395,  396,  397,  398,  399,  400,  401,   -1,  256,
+   -1,   -1,   -1,   -1,   -1,  262,   -1,   -1,   -1,  413,
+   -1,   -1,  416,   -1,  418,   -1,  420,   -1,   -1,  423,
+    0,   -1,   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,
+   -1,   -1,  371,  372,  373,  374,   -1,  294,   -1,  378,
+  379,  298,   -1,  382,  383,  384,  385,  386,  387,  388,
+  389,  390,   -1,  392,  393,  394,  395,  396,  397,  398,
+  399,  400,  401,  402,  403,  404,  405,  406,  407,  408,
+  409,  410,  411,  412,  413,   -1,   -1,   -1,   -1,   -1,
+   -1,  420,  339,    0,  423,   -1,   -1,  344,   -1,  346,
+  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  359,   -1,   -1,   -1,  363,  364,   -1,
-   -1,   -1,  256,  257,   -1,   -1,   -1,  261,   -1,   -1,
-  376,  265,   -1,  267,   -1,   -1,  270,   -1,  272,  273,
-   -1,  275,   -1,  277,   -1,  279,   -1,  281,  282,  283,
-  284,   -1,   -1,  287,  288,   -1,   -1,   -1,    0,  293,
-   -1,  295,  296,  297,   -1,   -1,  300,  301,  302,   -1,
-  304,  417,   -1,  307,   -1,  309,  310,  311,  312,   -1,
-   -1,   -1,  316,  317,  318,   -1,   -1,  321,  322,  323,
-   -1,  257,   -1,   -1,   -1,  261,  330,  331,   -1,  333,
-  334,    0,  336,  337,  338,   -1,  272,   -1,  342,   -1,
-   -1,  277,   -1,   -1,   -1,  281,   -1,   -1,  284,   -1,
-   -1,   -1,   -1,   -1,   -1,  359,   -1,   -1,   -1,   -1,
-  296,  297,   -1,  367,  368,  301,  302,   -1,   -1,   -1,
-   -1,  307,  376,  309,  310,  311,  312,   -1,   -1,   -1,
-   -1,  317,   -1,   -1,   -1,  321,   -1,  323,   -1,   -1,
-  257,   -1,   -1,   -1,  261,   -1,   -1,  333,    0,  335,
-  336,   -1,  338,   -1,   -1,  272,  342,   -1,   -1,   -1,
-  277,   -1,   -1,  417,  281,   -1,   -1,  284,   -1,   -1,
-   -1,   -1,   -1,  359,   -1,   -1,   -1,   -1,   -1,  296,
-  297,  367,  368,  257,  301,  302,   -1,  261,   -1,   -1,
-  307,    0,  309,  310,  311,  312,   -1,   -1,  272,   -1,
-  317,   -1,   -1,  277,  321,   -1,  323,  281,   -1,   -1,
-  284,   -1,   -1,   -1,   -1,   -1,  333,   -1,  335,  336,
+  367,  368,   -1,  370,  371,  372,   -1,  374,  375,  376,
+   -1,  378,  379,   -1,   -1,  382,  383,  384,  385,   -1,
+    0,   -1,  389,  390,   -1,   -1,   -1,  394,  395,  396,
+  397,  398,  399,  400,  401,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  413,   -1,  257,  416,
+   -1,  418,  261,   -1,  263,   -1,  265,   -1,  267,   -1,
+   -1,  270,  429,  272,  273,   -1,  275,   -1,  277,   -1,
+  279,   -1,  281,  282,  283,  284,   -1,   -1,  287,  288,
+   -1,   -1,   -1,    0,  293,  294,  295,  296,  297,   -1,
+   -1,  300,  301,  302,   -1,  304,   -1,  306,  307,  308,
+  309,  310,  311,  312,  313,   -1,  315,  316,  317,  318,
+   -1,   -1,  321,  322,  323,   -1,  325,   -1,   -1,   -1,
+   -1,  330,  331,   -1,  333,  334,    0,  336,  337,  338,
+   -1,   -1,   -1,  342,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  362,   -1,  364,  365,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  256,  257,  377,    0,
+   -1,  261,   -1,   -1,   -1,  265,   -1,  267,   -1,   -1,
+  270,   -1,  272,  273,   -1,  275,   -1,  277,   -1,  279,
+   -1,  281,  282,  283,  284,   -1,   -1,  287,  288,   -1,
+   -1,   -1,   -1,  293,   -1,  295,  296,  297,   -1,  418,
+  300,  301,  302,   -1,  304,   -1,   -1,  307,   -1,  309,
+  310,  311,  312,   -1,   -1,   -1,  316,  317,  318,   -1,
+  257,  321,  322,  323,  261,   -1,    0,   -1,   -1,   -1,
+  330,  331,   -1,  333,  334,  272,  336,  337,  338,   -1,
+  277,   -1,  342,   -1,  281,   -1,   -1,  284,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  296,
+  297,   -1,  362,   -1,  301,  302,   -1,  257,  368,  369,
+  307,  261,  309,  310,  311,  312,   -1,  377,   -1,   -1,
+  317,   -1,  272,   -1,  321,   -1,  323,  277,   -1,    0,
+   -1,  281,   -1,   -1,  284,   -1,  333,   -1,  335,  336,
+   -1,  338,   -1,   -1,   -1,  342,  296,  297,   -1,   -1,
+   -1,  301,  302,   -1,   -1,   -1,   -1,  307,  418,  309,
+  310,  311,  312,   -1,   -1,  362,   -1,  317,   -1,   -1,
+  257,  321,  369,  323,  261,   -1,    0,   -1,   -1,   -1,
+   -1,   -1,   -1,  333,   -1,  272,  336,   -1,  338,   -1,
+  277,   -1,  342,   -1,  281,   -1,   -1,  284,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  296,
+  297,   -1,  362,  257,  301,  302,   -1,  261,  368,  369,
+  307,   -1,  309,  310,  311,  312,   -1,   -1,  272,   -1,
+  317,   -1,   -1,  277,  321,   -1,  323,  281,   -1,    0,
+  284,   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,
    -1,  338,  296,  297,   -1,  342,  257,  301,  302,   -1,
-  261,   -1,   -1,  307,    0,  309,  310,  311,  312,   -1,
-   -1,  272,  359,  317,   -1,   -1,  277,  321,   -1,  323,
-  281,  368,   -1,  284,   -1,   -1,   -1,   -1,   -1,  333,
+  261,   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,
+   -1,  272,   -1,  317,   -1,  362,  277,  321,   -1,  323,
+  281,  368,  369,  284,   -1,   -1,   -1,   -1,   -1,  333,
    -1,   -1,  336,   -1,  338,  296,  297,   -1,  342,   -1,
   301,  302,   -1,   -1,   -1,   -1,  307,   -1,  309,  310,
-  311,  312,   -1,   -1,   -1,  359,  317,   -1,   -1,   -1,
-  321,   -1,  323,  367,  368,  257,   -1,   -1,   -1,  261,
-   -1,   -1,  333,   -1,   -1,  336,   -1,  338,   -1,   -1,
-  272,  342,   -1,   -1,   -1,  277,   -1,   -1,   -1,  281,
-   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,  359,   -1,
-   -1,   -1,   -1,   -1,  296,  297,  367,  368,  257,  301,
-  302,   -1,  261,   -1,   -1,  307,   -1,  309,  310,  311,
-  312,   -1,   -1,  272,   -1,  317,   -1,   -1,  277,  321,
-   -1,  323,  281,   -1,   -1,  284,   -1,   -1,   -1,   -1,
-   -1,  333,   -1,   -1,  336,   -1,  338,  296,  297,   -1,
-  342,   -1,  301,  302,   -1,   -1,   -1,   -1,  307,   -1,
-  309,  310,  311,  312,   -1,   -1,   -1,  359,  317,   -1,
-   -1,   -1,  321,   -1,  323,  257,  368,   -1,   -1,  261,
-   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,  338,
-  272,   -1,   -1,  342,   -1,  277,   -1,   -1,   -1,  281,
-   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  359,   -1,   -1,   -1,  296,  297,   -1,   -1,  257,  301,
-  302,   -1,  261,   -1,   -1,  307,   -1,  309,  310,  311,
-  312,   -1,   -1,  272,   -1,  317,   -1,   -1,  277,  321,
-   -1,  323,  281,   -1,   -1,  284,   -1,   -1,   -1,   -1,
-   -1,  333,   -1,   -1,  336,   -1,  338,  296,  297,   -1,
-  342,  257,  301,  302,   -1,  261,   -1,   -1,  307,   -1,
-  309,  310,  311,  312,   -1,   -1,  272,  359,  317,   -1,
-   -1,  277,  321,   -1,  323,  281,   -1,   -1,  284,   -1,
-   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,  338,
-  296,  297,   -1,  342,   -1,  301,  302,   -1,   -1,   -1,
-   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,
-  359,  317,   -1,   -1,   -1,  321,   -1,  323,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,  256,
-  336,   -1,  338,   -1,   -1,   -1,  342,  264,  265,  266,
-  267,   -1,   -1,  270,  271,   -1,  273,  274,  275,  276,
-  277,  278,  279,  359,   -1,   -1,   -1,   -1,  285,   -1,
-  287,  288,  289,  290,  291,  292,   -1,   -1,  295,   -1,
-   -1,   -1,  299,  300,   -1,  302,  303,  304,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  314,   -1,  316,
-   -1,  318,  319,   -1,   -1,  322,   -1,  324,  325,  326,
-  327,  328,  329,  330,  331,  332,  333,  334,  335,   -1,
-  337,   -1,   -1,  340,  341,  256,   -1,  344,  345,   -1,
-   -1,  262,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  360,  361,  362,   -1,   -1,   -1,  366,
-   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,  375,  376,
-  377,  378,  379,   -1,   -1,   -1,  383,  298,  385,   -1,
-   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  256,   -1,   -1,   -1,   -1,   -1,  262,   -1,  416,
-  417,  418,  419,   -1,   -1,   -1,   -1,   -1,  339,   -1,
-   -1,  428,   -1,  344,   -1,  346,  347,  348,  349,  350,
-  351,  352,  353,  354,  355,  356,  357,   -1,   -1,   -1,
-   -1,   -1,   -1,  298,   -1,   -1,  367,  368,  369,  370,
-  371,  372,  373,  374,  375,   -1,  377,  378,   -1,  380,
-  381,  382,  383,  384,  385,  386,  387,  388,  389,   -1,
-  391,  392,  393,  394,  395,  396,  397,  398,  399,  400,
-  401,  402,  403,  404,  405,  406,  407,  408,  409,  410,
-  411,  412,   -1,  256,   -1,   -1,  417,   -1,  419,  262,
-   -1,  422,   -1,   -1,   -1,   -1,   -1,  428,   -1,   -1,
-   -1,   -1,  367,   -1,   -1,  370,   -1,  372,  373,   -1,
-   -1,   -1,  377,  378,   -1,   -1,  381,  382,  383,  384,
-  385,  386,  387,  388,  389,  298,  391,  392,  393,  394,
-  395,  396,  397,  398,  399,  400,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  411,  412,   -1,   -1,
-   -1,   -1,   -1,   -1,  419,   -1,   -1,  422,   -1,   -1,
-   -1,   -1,   -1,  428,   -1,   -1,  339,   -1,   -1,   -1,
-   -1,  344,   -1,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  366,  367,  368,  369,  370,  371,  372,
-  373,  374,  375,  256,  377,  378,   -1,  380,  381,  382,
-  383,  384,  385,  386,  387,  388,  389,   -1,  391,  392,
-  393,  394,  395,  396,  397,  398,  399,  400,  401,  402,
-  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,
-   -1,  256,   -1,   -1,   -1,   -1,  419,  262,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  298,   -1,   -1,  339,   -1,   -1,   -1,
-   -1,  344,   -1,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  262,  367,   -1,  369,   -1,  371,   -1,
-  373,  374,  375,   -1,  339,   -1,   -1,   -1,   -1,  344,
+  311,  312,   -1,   -1,   -1,   -1,  317,   -1,  362,   -1,
+  321,   -1,  323,  257,   -1,  369,   -1,  261,   -1,   -1,
+   -1,   -1,  333,   -1,   -1,  336,   -1,  338,  272,   -1,
+   -1,  342,   -1,  277,   -1,   -1,   -1,  281,   -1,   -1,
+  284,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  362,  296,  297,   -1,   -1,   -1,  301,  302,   -1,
+   -1,   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,
+   -1,   -1,   -1,  317,   -1,   -1,  257,  321,   -1,  323,
+  261,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,
+   -1,  272,  336,   -1,  338,   -1,  277,   -1,  342,   -1,
+  281,   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  296,  297,   -1,  362,   -1,
+  301,  302,   -1,  257,   -1,   -1,  307,  261,  309,  310,
+  311,  312,   -1,   -1,   -1,   -1,  317,   -1,  272,   -1,
+  321,   -1,  323,  277,   -1,   -1,   -1,  281,   -1,   -1,
+  284,   -1,  333,   -1,   -1,  336,   -1,  338,   -1,   -1,
+   -1,  342,  296,  297,   -1,   -1,   -1,  301,  302,   -1,
+   -1,   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,
+   -1,  362,   -1,  317,   -1,   -1,  257,  321,   -1,  323,
+  261,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,
+   -1,  272,  336,   -1,  338,   -1,  277,   -1,  342,   -1,
+  281,   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  296,  297,   -1,  362,   -1,
+  301,  302,   -1,   -1,   -1,   -1,  307,   -1,  309,  310,
+  311,  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,   -1,
+  321,   -1,  323,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  333,   -1,  256,  336,   -1,  338,   -1,   -1,
+   -1,  342,  264,  265,  266,  267,   -1,   -1,  270,  271,
+   -1,  273,  274,  275,  276,  277,  278,  279,   -1,   -1,
+   -1,  362,   -1,  285,   -1,  287,  288,  289,  290,  291,
+  292,   -1,   -1,  295,   -1,   -1,   -1,  299,  300,   -1,
+  302,  303,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  314,   -1,  316,   -1,  318,  319,   -1,   -1,
+  322,   -1,  324,  325,  326,  327,  328,  329,  330,  331,
+  332,  333,  334,  335,   -1,  337,   -1,   -1,  340,  341,
+   -1,  256,  344,  345,   -1,   -1,   -1,  262,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,   -1,   -1,   -1,  367,   -1,   -1,   -1,  371,
+   -1,   -1,   -1,   -1,  376,  377,  378,  379,  380,   -1,
+   -1,   -1,  384,  298,  386,   -1,   -1,   -1,   -1,   -1,
+  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
+   -1,   -1,   -1,  262,   -1,  417,  418,  419,  420,   -1,
+   -1,   -1,   -1,   -1,  339,   -1,   -1,  429,   -1,  344,
    -1,  346,  347,  348,  349,  350,  351,  352,  353,  354,
-  355,  356,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  298,
-   -1,  366,  367,   -1,  369,  370,  371,  372,  373,  374,
-  375,   -1,  377,  378,   -1,  380,  381,  382,  383,  384,
-  385,  386,  387,  388,  389,  428,  391,  392,  393,  394,
+  355,  356,  357,   -1,   -1,   -1,   -1,   -1,   -1,  298,
+   -1,   -1,   -1,  368,  369,  370,  371,  372,  373,  374,
+  375,  376,   -1,  378,  379,   -1,  381,  382,  383,  384,
+  385,  386,  387,  388,  389,  390,   -1,  392,  393,  394,
   395,  396,  397,  398,  399,  400,  401,  402,  403,  404,
-  405,  406,  407,  408,  409,  410,  411,  412,   -1,  256,
-   -1,   -1,   -1,   -1,  419,  262,   -1,  422,  357,   -1,
-   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,  368,
-   -1,  370,   -1,  372,   -1,   -1,  375,   -1,  377,  378,
-   -1,  380,  381,  382,  383,  384,  385,  386,  387,  388,
-  389,  298,  391,  392,  393,  394,  395,  396,  397,  398,
-  399,  400,  401,  402,  403,  404,  405,  406,  407,  408,
-  409,  410,  411,  412,   -1,   -1,   -1,   -1,  417,   -1,
-  419,  262,   -1,  422,   -1,   -1,   -1,   -1,   -1,  428,
+  405,  406,  407,  408,  409,  410,  411,  412,  413,   -1,
+  256,   -1,   -1,  418,   -1,  420,  262,   -1,  423,   -1,
+   -1,   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,  368,
+   -1,   -1,  371,   -1,  373,  374,   -1,   -1,   -1,  378,
+  379,   -1,   -1,  382,  383,  384,  385,  386,  387,  388,
+  389,  390,  298,  392,  393,  394,  395,  396,  397,  398,
+  399,  400,  401,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  412,  413,   -1,   -1,   -1,   -1,   -1,
+   -1,  420,  262,   -1,  423,   -1,   -1,   -1,   -1,   -1,
+  429,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,   -1,
+  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
+  356,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  298,   -1,
+   -1,  367,  368,  369,  370,  371,  372,  373,  374,  375,
+  376,   -1,  378,  379,   -1,  381,  382,  383,  384,  385,
+  386,  387,  388,  389,  390,   -1,  392,  393,  394,  395,
+  396,  397,  398,  399,  400,  401,  402,  403,  404,  405,
+  406,  407,  408,  409,  410,  411,  412,  413,   -1,  256,
+   -1,   -1,   -1,   -1,  420,  262,   -1,  357,   -1,   -1,
+   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,   -1,  369,
+   -1,  371,   -1,  373,   -1,   -1,  376,   -1,  378,  379,
+   -1,  381,  382,  383,  384,  385,  386,  387,  388,  389,
+  390,  298,  392,  393,  394,  395,  396,  397,  398,  399,
+  400,  401,  402,  403,  404,  405,  406,  407,  408,  409,
+  410,  411,  412,  413,   -1,   -1,   -1,   -1,  418,   -1,
+  420,  262,   -1,  423,   -1,   -1,   -1,   -1,   -1,  429,
    -1,   -1,  339,   -1,   -1,   -1,   -1,  344,   -1,  346,
   347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,  298,   -1,   -1,
-  367,   -1,  369,  370,  371,  372,  373,  374,  375,   -1,
-  377,  378,   -1,  380,  381,  382,  383,  384,  385,  386,
-  387,  388,  389,   -1,  391,  392,  393,  394,  395,  396,
+  367,  368,   -1,  370,  371,  372,  373,  374,  375,  376,
+   -1,  378,  379,   -1,  381,  382,  383,  384,  385,  386,
+  387,  388,  389,  390,   -1,  392,  393,  394,  395,  396,
   397,  398,  399,  400,  401,  402,  403,  404,  405,  406,
-  407,  408,  409,  410,  411,  412,   -1,  256,   -1,   -1,
-   -1,   -1,  419,  262,   -1,  422,   -1,   -1,   -1,   -1,
-   -1,  428,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,
-  371,  372,  373,   -1,  375,   -1,  377,  378,   -1,  380,
-  381,  382,  383,  384,   -1,  386,  387,  388,  389,  298,
-  391,  392,  393,  394,  395,  396,  397,  398,  399,  400,
+  407,  408,  409,  410,  411,  412,  413,   -1,  256,   -1,
+   -1,   -1,   -1,  420,  262,   -1,  423,   -1,   -1,   -1,
+   -1,   -1,  429,   -1,   -1,   -1,   -1,   -1,  369,   -1,
+  371,  372,  373,  374,   -1,  376,   -1,  378,  379,   -1,
+  381,  382,  383,  384,  385,   -1,  387,  388,  389,  390,
+  298,  392,  393,  394,  395,  396,  397,  398,  399,  400,
   401,  402,  403,  404,  405,  406,  407,  408,  409,  410,
-  411,  412,   -1,   -1,   -1,   -1,  417,   -1,  419,  262,
-   -1,  422,   -1,   -1,   -1,   -1,   -1,  428,   -1,   -1,
+  411,  412,  413,   -1,   -1,   -1,   -1,  418,   -1,  420,
+  262,   -1,  423,   -1,   -1,   -1,   -1,   -1,  429,   -1,
+   -1,  339,   -1,   -1,   -1,   -1,  344,   -1,  346,  347,
+  348,  349,  350,  351,  352,  353,  354,  355,  356,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  298,   -1,   -1,   -1,
+  368,   -1,  370,  371,  372,  373,  374,  375,  376,   -1,
+  378,  379,   -1,  381,  382,  383,  384,  385,  386,  387,
+  388,  389,  390,   -1,  392,  393,  394,  395,  396,  397,
+  398,  399,  400,  401,  402,  403,  404,  405,  406,  407,
+  408,  409,  410,  411,  412,  413,   -1,  256,   -1,   -1,
+   -1,   -1,  420,  262,   -1,  423,   -1,   -1,   -1,   -1,
+   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,  370,  371,
+  372,  373,  374,   -1,   -1,   -1,  378,  379,   -1,  381,
+  382,  383,  384,  385,  386,  387,  388,  389,  390,  298,
+  392,  393,  394,  395,  396,  397,  398,  399,  400,  401,
+  402,  403,  404,  405,  406,  407,  408,  409,  410,  411,
+  412,  413,   -1,   -1,   -1,   -1,   -1,   -1,  420,   -1,
+   -1,  423,   -1,   -1,   -1,   -1,   -1,  429,   -1,   -1,
   339,   -1,   -1,   -1,   -1,  344,   -1,  346,  347,  348,
   349,  350,  351,  352,  353,  354,  355,  356,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  298,   -1,   -1,  367,   -1,
-  369,  370,  371,  372,  373,  374,  375,   -1,  377,  378,
-   -1,  380,  381,  382,  383,  384,  385,  386,  387,  388,
-  389,   -1,  391,  392,  393,  394,  395,  396,  397,  398,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  368,
+   -1,  370,  371,  372,  373,  374,  375,  376,   -1,  378,
+  379,   -1,  381,  382,  383,  384,  385,  386,  387,  388,
+  389,  390,   -1,  392,  393,  394,  395,  396,  397,  398,
   399,  400,  401,  402,  403,  404,  405,  406,  407,  408,
-  409,  410,  411,  412,   -1,  256,   -1,   -1,   -1,   -1,
-  419,  262,   -1,  422,   -1,   -1,   -1,   -1,   -1,  428,
-   -1,   -1,   -1,   -1,   -1,   -1,  369,  370,  371,  372,
-  373,   -1,   -1,   -1,  377,  378,   -1,  380,  381,  382,
-  383,  384,  385,  386,  387,  388,  389,  298,  391,  392,
-  393,  394,  395,  396,  397,  398,  399,  400,  401,  402,
-  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,
-   -1,   -1,   -1,   -1,   -1,   -1,  419,   -1,   -1,  422,
-   -1,   -1,   -1,   -1,   -1,  428,   -1,   -1,  339,   -1,
+  409,  410,  411,  412,  413,   -1,  256,  256,   -1,   -1,
+   -1,  420,  262,   -1,  423,   -1,  265,   -1,  267,   -1,
+  429,  270,   -1,   -1,   -1,   -1,  275,   -1,   -1,   -1,
+  279,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  288,
+   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,  298,   -1,
+   -1,  300,   -1,   -1,   -1,  304,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,
+   -1,   -1,   -1,  322,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  330,  331,   -1,   -1,  334,   -1,   -1,  337,  339,
+   -1,   -1,   -1,   -1,  344,   -1,  346,  347,  348,  349,
+  350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,
+  370,  371,  372,  373,  374,  375,  376,   -1,  378,  379,
+   -1,  381,  382,  383,  384,  385,  386,  387,  388,  389,
+  390,   -1,  392,  393,  394,  395,  396,  397,  398,  399,
+  400,  401,  402,  403,  404,  405,  406,  407,  408,  409,
+  410,  411,  412,  413,   -1,  256,  256,   -1,   -1,  418,
+  420,  262,   -1,  423,   -1,  265,   -1,  267,   -1,  429,
+  270,   -1,   -1,   -1,   -1,  275,   -1,   -1,   -1,  279,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  288,   -1,
+   -1,   -1,   -1,   -1,   -1,  295,   -1,  298,   -1,   -1,
+  300,   -1,   -1,   -1,  304,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,   -1,
+   -1,   -1,  322,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  330,  331,   -1,   -1,  334,   -1,   -1,  337,  339,   -1,
    -1,   -1,   -1,  344,   -1,  346,  347,  348,  349,  350,
   351,  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,  370,
-  371,  372,  373,  374,  375,   -1,  377,  378,   -1,  380,
-  381,  382,  383,  384,  385,  386,  387,  388,  389,   -1,
-  391,  392,  393,  394,  395,  396,  397,  398,  399,  400,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,
+  371,  372,  373,  374,  375,  376,   -1,  378,   -1,   -1,
+  381,  382,  383,  384,  385,  386,  387,  388,  389,  390,
+   -1,  392,  393,  394,  395,  396,  397,  398,  399,  400,
   401,  402,  403,  404,  405,  406,  407,  408,  409,  410,
-  411,  412,   -1,  256,  256,   -1,   -1,   -1,  419,  262,
-   -1,  422,   -1,  265,   -1,  267,   -1,  428,  270,   -1,
-   -1,   -1,   -1,  275,   -1,   -1,   -1,  279,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  288,   -1,   -1,   -1,
-   -1,   -1,   -1,  295,   -1,  298,   -1,   -1,  300,   -1,
-   -1,   -1,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  316,   -1,  318,   -1,   -1,   -1,
-  322,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,
-   -1,   -1,  334,   -1,   -1,  337,  339,   -1,   -1,   -1,
-   -1,  344,   -1,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  367,   -1,  369,  370,  371,  372,
-  373,  374,  375,   -1,  377,   -1,   -1,  380,  381,  382,
-  383,  384,  385,  386,  387,  388,  389,   -1,  391,  392,
-  393,  394,  395,  396,  397,  398,  399,  400,  401,  402,
-  403,  404,  405,  406,  407,  408,  409,  410,  411,  412,
-   -1,  256,  256,   -1,   -1,  417,  419,  262,   -1,  422,
-   -1,  265,   -1,  267,   -1,  428,  270,   -1,   -1,   -1,
-   -1,  275,   -1,   -1,   -1,  279,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,
-   -1,  295,   -1,  298,   -1,   -1,  300,   -1,   -1,   -1,
-  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  316,   -1,  318,   -1,   -1,   -1,  322,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,   -1,   -1,
-  334,   -1,   -1,  337,  339,   -1,  256,   -1,   -1,  344,
-   -1,  346,  347,  348,  349,  350,  351,  352,  353,  354,
-  355,  356,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  367,   -1,  369,   -1,  371,   -1,  373,  374,
-  375,   -1,  377,  378,   -1,  380,  381,  382,  383,  384,
-  385,  386,  387,  388,  389,   -1,   -1,   -1,  393,  394,
-  395,  396,  397,  398,  399,  400,  401,  402,  403,  404,
-  405,  406,  407,  408,  409,  410,  256,  412,   -1,   -1,
-   -1,   -1,  262,  417,   -1,   -1,  261,   -1,   -1,  339,
-   -1,   -1,   -1,  428,  344,   -1,  346,  347,  348,  349,
-  350,  351,  352,  353,  354,  355,  356,   -1,   -1,  284,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  367,  298,  369,
-   -1,  371,  297,  373,  374,  375,   -1,  302,   -1,   -1,
-   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,  389,
-  315,   -1,  317,  256,   -1,   -1,  321,   -1,   -1,  262,
-  400,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  333,  339,
-   -1,  336,  412,  338,  344,   -1,  346,  347,  348,  349,
-  350,  351,  352,  353,  354,  355,  356,   -1,  428,   -1,
-   -1,   -1,   -1,   -1,  359,  298,   -1,  367,   -1,  369,
-   -1,  371,  367,  373,  374,  375,   -1,  377,  378,   -1,
-   -1,  381,  382,  383,  384,  385,  386,  387,  388,  389,
-   -1,   -1,   -1,  393,  394,  395,  396,  397,  398,  399,
-  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,
-   -1,  344,  412,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,  256,   -1,  428,   -1,
-   -1,   -1,  262,   -1,  367,   -1,  369,   -1,  371,   -1,
-  373,  374,  375,   -1,  377,  378,   -1,   -1,  381,  382,
-  383,  384,   -1,   -1,   -1,  388,  389,   -1,   -1,   -1,
-  393,  394,  395,  396,  397,  398,  399,  400,  298,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  412,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  256,   -1,  428,   -1,   -1,   -1,  262,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  339,
-   -1,   -1,   -1,   -1,  344,   -1,  346,  347,  348,  349,
-  350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  298,   -1,  367,   -1,  369,
-   -1,  371,   -1,  373,  374,  375,   -1,  377,  378,   -1,
-   -1,  381,  382,  383,  384,   -1,   -1,   -1,  388,  389,
-   -1,   -1,   -1,  393,  394,  395,  396,  397,  398,  399,
-  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,
-   -1,  344,  412,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,  256,   -1,  428,   -1,
-   -1,   -1,  262,   -1,  367,   -1,  369,   -1,  371,   -1,
-  373,  374,  375,   -1,  377,  378,   -1,   -1,  381,  382,
-  383,  384,   -1,   -1,   -1,  388,  389,   -1,   -1,   -1,
-  393,  394,  395,  396,  397,  398,  399,  400,  298,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  412,
+  411,  412,  413,   -1,  256,   -1,  256,   -1,  418,  420,
+  262,   -1,  423,   -1,  264,  265,   -1,  267,  429,   -1,
+  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
+   -1,   -1,   -1,   -1,   -1,  285,   -1,   -1,  288,   -1,
+   -1,   -1,   -1,   -1,   -1,  295,  298,   -1,   -1,   -1,
+  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
+   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
+  330,  331,  332,   -1,  334,   -1,   -1,  339,   -1,   -1,
+   -1,   -1,  344,   -1,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,  359,
+  360,  361,   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,
+  372,  371,  374,  375,  376,   -1,  378,  379,   -1,  381,
+  382,  383,  384,  385,  386,  387,  388,  389,  390,  261,
+   -1,   -1,  394,  395,  396,  397,  398,  399,  400,  401,
+  402,  403,  404,  405,  406,  407,  408,  409,  410,  411,
+  256,  413,  284,   -1,   -1,   -1,  262,  417,  418,   -1,
+   -1,   -1,   -1,   -1,   -1,  297,   -1,  429,   -1,   -1,
+  302,   -1,   -1,  305,   -1,  307,   -1,  309,  310,  311,
+  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,   -1,  321,
+   -1,   -1,  298,  325,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  333,   -1,   -1,  336,   -1,  338,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,
+   -1,   -1,   -1,   -1,  262,   -1,   -1,   -1,   -1,   -1,
+  362,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,   -1,
+  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
+  356,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  298,   -1,  368,   -1,  370,   -1,  372,   -1,  374,  375,
+  376,   -1,  378,  379,   -1,   -1,  382,  383,  384,  385,
+  386,  387,  388,  389,  390,   -1,  418,   -1,  394,  395,
+  396,  397,  398,  399,  400,  401,   -1,   -1,   -1,   -1,
+   -1,  339,   -1,   -1,   -1,   -1,  344,  413,  346,  347,
+  348,  349,  350,  351,  352,  353,  354,  355,  356,   -1,
+   -1,   -1,  256,  429,   -1,   -1,   -1,   -1,  262,   -1,
+  368,   -1,  370,   -1,  372,   -1,  374,  375,  376,   -1,
+  378,  379,   -1,   -1,  382,  383,  384,  385,   -1,   -1,
+   -1,  389,  390,   -1,   -1,   -1,  394,  395,  396,  397,
+  398,  399,  400,  401,  298,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  413,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  256,   -1,  428,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  339,
-   -1,   -1,   -1,   -1,  344,   -1,  346,  347,  348,  349,
-  350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,
-   -1,  371,   -1,  373,  374,  375,   -1,  377,  378,   -1,
-   -1,  381,  382,  383,  384,   -1,   -1,   -1,  388,  389,
-  256,   -1,   -1,  393,  394,  395,  396,  397,  398,  399,
-  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,
-   -1,  344,  412,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,   -1,   -1,  428,   -1,
-   -1,   -1,   -1,   -1,  367,   -1,  369,   -1,  371,   -1,
-  373,  374,  375,   -1,   -1,   -1,   -1,   -1,  381,  382,
-  383,  384,   -1,   -1,   -1,  388,  389,  256,   -1,   -1,
-  393,  394,  395,  396,  397,  398,  399,  400,   -1,   -1,
-   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  412,
+  256,  429,   -1,   -1,   -1,   -1,  262,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,
+  344,   -1,  346,  347,  348,  349,  350,  351,  352,  353,
+  354,  355,  356,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  298,   -1,  368,   -1,  370,   -1,  372,   -1,
+  374,  375,  376,   -1,  378,  379,   -1,   -1,  382,  383,
+  384,  385,   -1,   -1,   -1,  389,  390,  285,   -1,   -1,
+  394,  395,  396,  397,  398,  399,  400,  401,   -1,   -1,
+   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  413,
   346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
-  356,   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,
-   -1,  367,   -1,  369,   -1,  371,   -1,  373,  374,  375,
-   -1,   -1,   -1,   -1,   -1,  381,  382,  383,  384,   -1,
-   -1,   -1,  388,  389,  256,   -1,   -1,  393,  394,  395,
-  396,  397,  398,  399,  400,   -1,   -1,   -1,   -1,   -1,
-  339,   -1,   -1,   -1,   -1,  344,  412,  346,  347,  348,
-  349,  350,  351,  352,  353,  354,  355,  356,   -1,   -1,
-   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,  367,   -1,
-  369,   -1,  371,   -1,  373,  374,  375,   -1,   -1,   -1,
-   -1,   -1,  381,  382,  383,  384,   -1,   -1,   -1,  388,
-  389,  256,   -1,   -1,  393,  394,  395,  396,  397,  398,
-  399,  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,
-   -1,   -1,  344,  412,  346,  347,  348,  349,  350,  351,
-  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,  428,
-   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,   -1,  371,
-   -1,  373,  374,  375,   -1,   -1,   -1,   -1,   -1,  381,
-  382,  383,  384,   -1,   -1,   -1,  388,  389,  256,   -1,
-   -1,   -1,   -1,  395,  396,  397,  398,  399,  400,   -1,
-   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,
-  412,  346,  347,  348,  349,  350,  351,  352,  353,  354,
-  355,  356,   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,
-   -1,   -1,  367,   -1,  369,   -1,  371,   -1,  373,  374,
-  375,   -1,   -1,   -1,   -1,   -1,  381,  382,  383,  384,
-   -1,   -1,   -1,  388,  389,  256,   -1,   -1,   -1,   -1,
-  395,  396,  397,  398,  399,  400,   -1,   -1,   -1,   -1,
-   -1,  339,   -1,   -1,   -1,   -1,  344,  412,  346,  347,
+  356,   -1,   -1,   -1,  256,  429,   -1,   -1,   -1,  327,
+  262,   -1,  368,   -1,  370,   -1,  372,   -1,  374,  375,
+  376,   -1,  378,  379,   -1,   -1,  382,  383,  384,  385,
+   -1,   -1,   -1,  389,  390,   -1,   -1,   -1,  394,  395,
+  396,  397,  398,  399,  400,  401,  298,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  413,   -1,  377,
+  378,  379,  380,   -1,  382,  383,  384,  385,  386,  387,
+  388,  389,  256,  429,  392,  393,  394,  395,  396,  397,
+  398,  399,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,
+   -1,   -1,  344,   -1,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,
+  372,   -1,  374,  375,  376,   -1,  378,  379,   -1,   -1,
+  382,  383,  384,  385,   -1,   -1,   -1,  389,  390,   -1,
+  256,   -1,  394,  395,  396,  397,  398,  399,  400,  401,
+   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,
+  344,  413,  346,  347,  348,  349,  350,  351,  352,  353,
+  354,  355,  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,
+   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,  372,   -1,
+  374,  375,  376,   -1,   -1,   -1,   -1,   -1,  382,  383,
+  384,  385,   -1,   -1,   -1,  389,  390,   -1,  256,   -1,
+  394,  395,  396,  397,  398,  399,  400,  401,   -1,   -1,
+   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  413,
+  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
+  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,
+   -1,   -1,  368,   -1,  370,   -1,  372,   -1,  374,  375,
+  376,   -1,   -1,   -1,   -1,   -1,  382,  383,  384,  385,
+   -1,   -1,   -1,  389,  390,   -1,  256,   -1,  394,  395,
+  396,  397,  398,  399,  400,  401,   -1,   -1,   -1,   -1,
+   -1,  339,   -1,   -1,   -1,   -1,  344,  413,  346,  347,
   348,  349,  350,  351,  352,  353,  354,  355,  356,   -1,
-   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,  367,
-   -1,  369,   -1,  371,   -1,  373,  374,  375,   -1,   -1,
-   -1,   -1,   -1,  381,  382,  383,  384,   -1,   -1,   -1,
-  388,  389,  256,   -1,   -1,   -1,   -1,  395,  396,  397,
-  398,  399,  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,
-   -1,   -1,   -1,  344,  412,  346,  347,  348,  349,  350,
-  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,
-  428,   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,   -1,
-  371,   -1,  373,  374,  375,   -1,   -1,   -1,   -1,   -1,
-  381,  382,  383,  384,   -1,   -1,   -1,  388,  389,  256,
-   -1,   -1,   -1,   -1,  395,  396,  397,  398,  399,  400,
+   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,
+  368,   -1,  370,   -1,  372,   -1,  374,  375,  376,   -1,
+   -1,   -1,   -1,   -1,  382,  383,  384,  385,   -1,   -1,
+   -1,  389,  390,   -1,  256,   -1,  394,  395,  396,  397,
+  398,  399,  400,  401,   -1,   -1,   -1,   -1,   -1,  339,
+   -1,   -1,   -1,   -1,  344,  413,  346,  347,  348,  349,
+  350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
+   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,
+  370,   -1,  372,   -1,  374,  375,  376,   -1,   -1,   -1,
+   -1,   -1,  382,  383,  384,  385,   -1,   -1,   -1,  389,
+  390,   -1,  256,   -1,   -1,   -1,  396,  397,  398,  399,
+  400,  401,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,
+   -1,   -1,  344,  413,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,  429,
+   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,
+  372,   -1,  374,  375,  376,   -1,   -1,   -1,   -1,   -1,
+  382,  383,  384,  385,   -1,   -1,   -1,  389,  390,   -1,
+  256,   -1,   -1,   -1,  396,  397,  398,  399,  400,  401,
    -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,
-  344,  412,  346,  347,  348,  349,  350,  351,  352,  353,
-  354,  355,  356,   -1,   -1,   -1,   -1,  428,   -1,   -1,
-   -1,   -1,   -1,  367,   -1,  369,   -1,  371,   -1,  373,
-  374,  375,   -1,   -1,   -1,   -1,   -1,  381,  382,  383,
-  384,   -1,   -1,   -1,  388,  389,  256,   -1,   -1,   -1,
-   -1,  395,  396,  397,  398,  399,  400,   -1,   -1,   -1,
-   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  412,  346,
-  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
-   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,
-  367,   -1,  369,   -1,  371,   -1,  373,  374,  375,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  383,  384,   -1,   -1,
-   -1,  388,  389,  256,   -1,   -1,   -1,   -1,   -1,   -1,
-  397,  398,  399,  400,   -1,   -1,   -1,   -1,   -1,  339,
-   -1,   -1,   -1,   -1,  344,  412,  346,  347,  348,  349,
+  344,  413,  346,  347,  348,  349,  350,  351,  352,  353,
+  354,  355,  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,
+   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,  372,   -1,
+  374,  375,  376,   -1,   -1,   -1,   -1,   -1,  382,  383,
+  384,  385,   -1,   -1,   -1,  389,  390,   -1,  256,   -1,
+   -1,   -1,  396,  397,  398,  399,  400,  401,   -1,   -1,
+   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  413,
+  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
+  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,
+   -1,   -1,  368,   -1,  370,   -1,  372,   -1,  374,  375,
+  376,   -1,   -1,   -1,   -1,   -1,  382,  383,  384,  385,
+   -1,   -1,   -1,  389,  390,   -1,  256,   -1,   -1,   -1,
+  396,  397,  398,  399,  400,  401,   -1,   -1,   -1,   -1,
+   -1,  339,   -1,   -1,   -1,   -1,  344,  413,  346,  347,
+  348,  349,  350,  351,  352,  353,  354,  355,  356,   -1,
+   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,
+  368,   -1,  370,   -1,  372,   -1,  374,  375,  376,   -1,
+   -1,   -1,   -1,   -1,  382,  383,  384,  385,   -1,   -1,
+   -1,  389,  390,   -1,  256,   -1,   -1,   -1,  396,  397,
+  398,  399,  400,  401,   -1,   -1,   -1,   -1,   -1,  339,
+   -1,   -1,   -1,   -1,  344,  413,  346,  347,  348,  349,
   350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
-   -1,  428,   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,
-   -1,  371,   -1,  373,  374,  375,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  383,  384,   -1,   -1,   -1,  388,  389,
-  256,   -1,   -1,   -1,   -1,   -1,   -1,  397,  398,  399,
-  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,
-   -1,  344,  412,  346,  347,  348,  349,  350,  351,  352,
-  353,  354,  355,  356,   -1,   -1,   -1,   -1,  428,   -1,
-   -1,   -1,   -1,   -1,  367,   -1,  369,   -1,  371,   -1,
-  373,  374,  375,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  383,  384,   -1,   -1,   -1,  388,  389,  256,   -1,   -1,
-   -1,   -1,   -1,   -1,  397,  398,  399,  400,   -1,   -1,
-   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  412,
+   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,
+  370,   -1,  372,   -1,  374,  375,  376,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  384,  385,   -1,   -1,   -1,  389,
+  390,   -1,  256,   -1,   -1,   -1,   -1,   -1,  398,  399,
+  400,  401,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,
+   -1,   -1,  344,  413,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,  429,
+   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,
+  372,   -1,  374,  375,  376,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  384,  385,   -1,   -1,   -1,  389,  390,   -1,
+  256,   -1,   -1,   -1,   -1,   -1,  398,  399,  400,  401,
+   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,
+  344,  413,  346,  347,  348,  349,  350,  351,  352,  353,
+  354,  355,  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,
+   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,  372,   -1,
+  374,  375,  376,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  384,  385,   -1,   -1,   -1,  389,  390,   -1,  256,   -1,
+   -1,   -1,   -1,   -1,  398,  399,  400,  401,   -1,   -1,
+   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  413,
   346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
-  356,   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,
-   -1,  367,   -1,  369,   -1,  371,   -1,  373,  374,  375,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  383,  384,   -1,
-   -1,   -1,  388,  389,  256,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  399,  400,   -1,   -1,   -1,   -1,   -1,
-  339,   -1,   -1,   -1,   -1,  344,  412,  346,  347,  348,
-  349,  350,  351,  352,  353,  354,  355,  356,   -1,   -1,
-   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,  367,   -1,
-  369,   -1,  371,   -1,  373,  374,  375,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  383,  384,   -1,   -1,   -1,  388,
-  389,  256,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  399,  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,
-   -1,   -1,  344,  412,  346,  347,  348,  349,  350,  351,
-  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,  428,
-   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,   -1,  371,
-   -1,  373,  374,  375,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  384,   -1,   -1,   -1,  388,  389,  256,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  399,  400,   -1,
-   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,
-  412,  346,  347,  348,  349,  350,  351,  352,  353,  354,
-  355,  356,   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,
-   -1,   -1,  367,   -1,  369,   -1,  371,   -1,  373,  374,
-  375,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  384,
-   -1,   -1,   -1,  388,  389,  256,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  399,  400,   -1,   -1,   -1,   -1,
-   -1,  339,   -1,   -1,   -1,   -1,  344,  412,  346,  347,
+  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,
+   -1,   -1,  368,   -1,  370,   -1,  372,   -1,  374,  375,
+  376,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  384,  385,
+   -1,   -1,   -1,  389,  390,   -1,  256,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  400,  401,   -1,   -1,   -1,   -1,
+   -1,  339,   -1,   -1,   -1,   -1,  344,  413,  346,  347,
   348,  349,  350,  351,  352,  353,  354,  355,  356,   -1,
-   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,  367,
-   -1,  369,   -1,  371,   -1,  373,  374,  375,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  384,   -1,   -1,   -1,
-   -1,  389,  256,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  399,  400,   -1,   -1,   -1,   -1,   -1,  339,   -1,
-   -1,   -1,   -1,  344,  412,  346,  347,  348,  349,  350,
-  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,
-  428,   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,   -1,
-  371,   -1,  373,  374,  375,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  384,   -1,   -1,   -1,   -1,  389,  256,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  399,  400,
+   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,
+  368,   -1,  370,   -1,  372,   -1,  374,  375,  376,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  384,  385,   -1,   -1,
+   -1,  389,  390,   -1,  256,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  400,  401,   -1,   -1,   -1,   -1,   -1,  339,
+   -1,   -1,   -1,   -1,  344,  413,  346,  347,  348,  349,
+  350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
+   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,
+  370,   -1,  372,   -1,  374,  375,  376,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  385,   -1,   -1,   -1,  389,
+  390,   -1,  256,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  400,  401,   -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,
+   -1,   -1,  344,  413,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,   -1,   -1,   -1,   -1,  429,
+   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,
+  372,   -1,  374,  375,  376,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  385,   -1,   -1,   -1,  389,  390,   -1,
+  256,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  400,  401,
    -1,   -1,   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,
-  344,  412,  346,  347,  348,  349,  350,  351,  352,  353,
-  354,  355,  356,   -1,   -1,   -1,   -1,  428,   -1,   -1,
-   -1,   -1,   -1,  367,   -1,  369,   -1,  371,   -1,  373,
-  374,  375,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  389,  256,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  399,  400,   -1,   -1,   -1,
-   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  412,  346,
-  347,  348,  349,  350,  351,  352,  353,  354,  355,  356,
-   -1,   -1,   -1,   -1,  428,   -1,   -1,   -1,   -1,   -1,
-  367,   -1,  369,   -1,  371,   -1,  373,  374,  375,   -1,
+  344,  413,  346,  347,  348,  349,  350,  351,  352,  353,
+  354,  355,  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,
+   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,  372,   -1,
+  374,  375,  376,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  385,   -1,   -1,   -1,   -1,  390,   -1,  256,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  400,  401,   -1,   -1,
+   -1,   -1,   -1,  339,   -1,   -1,   -1,   -1,  344,  413,
+  346,  347,  348,  349,  350,  351,  352,  353,  354,  355,
+  356,   -1,   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,
+   -1,   -1,  368,   -1,  370,   -1,  372,   -1,  374,  375,
+  376,   -1,   -1,   -1,  256,   -1,   -1,   -1,   -1,  385,
+   -1,   -1,   -1,   -1,  390,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  400,  401,   -1,   -1,   -1,   -1,
+   -1,  339,   -1,   -1,   -1,   -1,  344,  413,  346,  347,
+  348,  349,  350,  351,  352,  353,  354,  355,  356,   -1,
+   -1,   -1,   -1,  429,   -1,   -1,   -1,   -1,   -1,   -1,
+  368,   -1,  370,   -1,  372,   -1,  374,  375,  376,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  389,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  400,   -1,   -1,   -1,   -1,   -1,  339,
-   -1,   -1,   -1,   -1,  344,  412,  346,  347,  348,  349,
-  350,  351,  352,  353,  354,  355,  356,   -1,   -1,   -1,
-   -1,  428,   -1,   -1,   -1,   -1,   -1,  367,   -1,  369,
-   -1,  371,   -1,  373,  374,  375,  256,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  264,  265,  266,  267,   -1,  389,
+   -1,   -1,  390,   -1,   -1,   -1,   -1,  339,   -1,   -1,
+   -1,   -1,  344,  401,  346,  347,  348,  349,  350,  351,
+  352,  353,  354,  355,  356,  413,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  368,   -1,  370,   -1,
+  372,  429,  374,  375,  376,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,  390,   -1,
+   -1,   -1,   -1,   -1,  264,  265,  266,  267,   -1,  401,
   270,  271,   -1,  273,  274,  275,  276,  277,  278,  279,
-   -1,   -1,   -1,   -1,   -1,  285,   -1,  287,  288,  289,
-  290,  291,  292,   -1,   -1,  295,   -1,   -1,   -1,  299,
-  300,   -1,  302,  303,  304,   -1,   -1,   -1,  428,   -1,
+   -1,  413,   -1,   -1,   -1,  285,   -1,  287,  288,  289,
+  290,  291,  292,   -1,   -1,  295,   -1,  429,   -1,  299,
+  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,  314,   -1,  316,   -1,  318,  319,
    -1,   -1,  322,   -1,  324,  325,  326,  327,  328,  329,
   330,  331,  332,  333,  334,  335,   -1,  337,   -1,   -1,
   340,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,
+  360,  361,   -1,  363,   -1,   -1,   -1,  367,   -1,   -1,
+   -1,  371,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
+  380,   -1,   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,
+   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,  366,   -1,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,  375,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  256,   -1,   -1,   -1,  417,  418,  419,
+  420,  264,  265,  266,  267,   -1,   -1,  270,  271,   -1,
+  273,  274,  275,  276,  277,  278,  279,   -1,   -1,   -1,
+   -1,   -1,  285,   -1,  287,  288,  289,  290,  291,  292,
+   -1,   -1,  295,   -1,   -1,   -1,  299,  300,   -1,  302,
+  303,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  314,   -1,  316,   -1,  318,  319,   -1,   -1,  322,
+   -1,  324,  325,  326,  327,  328,  329,  330,  331,  332,
+  333,  334,  335,   -1,  337,   -1,   -1,  340,  341,   -1,
+   -1,  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,   -1,
+  363,   -1,   -1,   -1,  367,   -1,   -1,   -1,  371,   -1,
+   -1,   -1,   -1,  376,  377,  378,  379,  380,   -1,   -1,
+   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,  392,
+  393,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  256,   -1,   -1,   -1,  416,  417,  418,  419,
-  264,  265,  266,  267,   -1,   -1,  270,  271,   -1,  273,
-  274,  275,  276,  277,  278,  279,   -1,   -1,   -1,   -1,
-   -1,  285,   -1,  287,  288,  289,  290,  291,  292,   -1,
-   -1,  295,   -1,   -1,   -1,  299,  300,   -1,  302,  303,
-  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  314,   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,
-  324,  325,  326,  327,  328,  329,  330,  331,  332,  333,
-  334,  335,   -1,  337,   -1,   -1,  340,  341,   -1,   -1,
-  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,
-   -1,   -1,  366,   -1,   -1,   -1,  370,   -1,   -1,   -1,
-   -1,  375,  376,  377,  378,  379,   -1,   -1,   -1,  383,
-   -1,  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,
+  256,   -1,   -1,   -1,  417,  418,  419,  420,  264,  265,
+  266,  267,   -1,   -1,  270,  271,   -1,  273,  274,  275,
+  276,  277,  278,  279,   -1,   -1,   -1,   -1,   -1,  285,
+   -1,  287,  288,  289,  290,  291,  292,   -1,   -1,  295,
+   -1,   -1,   -1,  299,  300,   -1,  302,  303,  304,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  314,   -1,
+  316,   -1,  318,  319,   -1,   -1,  322,   -1,  324,  325,
+  326,  327,  328,  329,  330,  331,  332,  333,  334,  335,
+   -1,  337,   -1,   -1,  340,  341,   -1,   -1,  344,  345,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,
-   -1,   -1,  416,  417,  418,  419,  264,  265,  266,  267,
-   -1,   -1,  270,  271,   -1,  273,  274,  275,  276,  277,
-  278,  279,   -1,   -1,   -1,   -1,   -1,  285,   -1,  287,
-  288,  289,  290,  291,  292,   -1,   -1,  295,   -1,   -1,
-   -1,  299,  300,   -1,  302,  303,  304,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  314,   -1,  316,   -1,
-  318,  319,   -1,   -1,  322,   -1,  324,  325,  326,  327,
-  328,  329,  330,  331,  332,  333,  334,  335,   -1,  337,
-   -1,   -1,  340,  341,   -1,   -1,  344,  345,   -1,   -1,
+   -1,   -1,   -1,  359,  360,  361,   -1,  363,   -1,   -1,
+   -1,  367,   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,
+  376,  377,  378,  379,  380,   -1,   -1,   -1,  384,   -1,
+  386,   -1,   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,
+   -1,  417,  418,  419,  420,  264,  265,  266,  267,   -1,
+   -1,  270,  271,   -1,  273,  274,  275,  276,  277,  278,
+  279,   -1,   -1,   -1,   -1,   -1,  285,   -1,  287,  288,
+  289,  290,  291,  292,   -1,   -1,  295,   -1,   -1,   -1,
+  299,  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  314,   -1,  316,   -1,  318,
+  319,   -1,   -1,  322,   -1,  324,  325,  326,  327,  328,
+  329,  330,  331,  332,  333,  334,  335,   -1,  337,   -1,
+   -1,  340,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  360,  361,  362,   -1,   -1,   -1,  366,   -1,
-   -1,   -1,  370,   -1,   -1,   -1,   -1,  375,  376,  377,
-  378,  379,   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,
-   -1,   -1,   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,
+  359,  360,  361,   -1,  363,   -1,   -1,   -1,  367,   -1,
+   -1,   -1,  371,   -1,   -1,   -1,   -1,  376,  377,  378,
+  379,  380,   -1,   -1,   -1,  384,   -1,  386,   -1,   -1,
+   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  256,   -1,   -1,   -1,  416,  417,
-  418,  419,  264,  265,  266,  267,   -1,   -1,  270,  271,
+   -1,   -1,   -1,   -1,  256,   -1,   -1,   -1,  417,  418,
+  419,  420,  264,  265,  266,  267,   -1,   -1,  270,  271,
    -1,  273,  274,  275,  276,  277,  278,  279,   -1,   -1,
    -1,   -1,   -1,  285,   -1,  287,  288,  289,  290,  291,
   292,   -1,   -1,  295,   -1,   -1,   -1,  299,  300,   -1,
@@ -11256,582 +11298,557 @@ void case_946()
   322,   -1,  324,  325,  326,  327,  328,  329,  330,  331,
   332,  333,  334,  335,   -1,  337,   -1,   -1,  340,  341,
    -1,   -1,  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  360,  361,
-  362,   -1,   -1,   -1,  366,   -1,   -1,   -1,  370,   -1,
-   -1,   -1,   -1,  375,  376,  377,  378,  379,   -1,   -1,
-   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,   -1,  391,
-  392,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,   -1,   -1,   -1,  367,   -1,   -1,   -1,  371,
+   -1,   -1,   -1,   -1,  376,  377,  378,  379,  380,   -1,
+   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,
+  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  256,   -1,   -1,   -1,  416,  417,  418,  419,  264,  265,
-  266,  267,   -1,   -1,  270,  271,   -1,  273,  274,  275,
-  276,  277,  278,  279,   -1,   -1,   -1,   -1,   -1,  285,
-   -1,  287,  288,  289,  290,  291,  292,   -1,   -1,  295,
-   -1,   -1,   -1,  299,  300,   -1,  302,  303,  304,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  314,   -1,
-  316,   -1,  318,  319,   -1,   -1,  322,   -1,  324,  325,
-  326,  327,  328,  329,  330,  331,  332,  333,  334,  335,
-   -1,  337,   -1,   -1,  340,  341,   -1,   -1,  344,  345,
+   -1,  256,   -1,   -1,   -1,  417,  418,  419,  420,  264,
+  265,   -1,  267,   -1,   -1,  270,  271,   -1,  256,   -1,
+  275,  276,  277,   -1,  279,   -1,   -1,  265,   -1,  267,
+  285,   -1,  270,  288,   -1,   -1,   -1,  275,   -1,   -1,
+  295,  279,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
+  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,
+   -1,  316,  300,  318,  319,   -1,  304,  322,   -1,   -1,
+  325,   -1,  327,   -1,  329,  330,  331,  332,  316,  334,
+  318,   -1,   -1,   -1,  322,   -1,  341,   -1,   -1,  344,
+  345,   -1,  330,  331,   -1,   -1,  334,   -1,   -1,  337,
+   -1,   -1,   -1,   -1,  359,  360,  361,   -1,  363,   -1,
+   -1,   -1,  367,  368,   -1,   -1,  371,   -1,   -1,   -1,
+   -1,   -1,  377,  378,  379,  380,   -1,   -1,   -1,  384,
+   -1,  386,   -1,   -1,   -1,   -1,   -1,  392,  393,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,   -1,
-  366,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,  375,
-  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,  385,
-   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,
+   -1,   -1,  417,  418,  419,  420,  264,  265,   -1,  267,
+   -1,   -1,  270,  271,   -1,  256,   -1,  275,  276,  277,
+  418,  279,   -1,   -1,  265,   -1,  267,  285,   -1,  270,
+  288,   -1,   -1,   -1,  275,   -1,   -1,  295,  279,   -1,
+   -1,   -1,  300,   -1,  302,  303,  304,  288,   -1,   -1,
+   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,  316,  300,
+  318,  319,  320,  304,  322,   -1,   -1,  325,   -1,  327,
+   -1,  329,  330,  331,  332,  316,  334,  318,   -1,   -1,
+   -1,  322,   -1,  341,   -1,   -1,  344,  345,   -1,  330,
+  331,   -1,   -1,  334,   -1,   -1,  337,   -1,   -1,   -1,
+   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,  367,
+   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,   -1,  377,
+  378,  379,  380,   -1,   -1,   -1,  384,   -1,  386,   -1,
+   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,
+   -1,   -1,  264,  265,   -1,  267,   -1,   -1,  270,  271,
+   -1,   -1,   -1,  275,  276,  277,   -1,  279,   -1,  417,
+  418,  419,  420,  285,   -1,   -1,  288,   -1,   -1,   -1,
+   -1,   -1,   -1,  295,   -1,   -1,   -1,  418,  300,   -1,
+  302,  303,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  316,   -1,  318,  319,   -1,   -1,
+  322,   -1,   -1,  325,   -1,  327,   -1,  329,  330,  331,
+  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,
+   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,   -1,   -1,   -1,  367,  368,   -1,   -1,  371,
+   -1,   -1,   -1,   -1,   -1,  377,  378,  379,  380,   -1,
+   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,
+  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,   -1,
-  416,  417,  418,  419,  264,  265,   -1,  267,   -1,   -1,
-  270,  271,   -1,  256,   -1,  275,  276,  277,   -1,  279,
-   -1,   -1,  265,   -1,  267,  285,   -1,  270,  288,   -1,
-   -1,   -1,  275,   -1,   -1,  295,  279,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,  288,   -1,   -1,   -1,   -1,
-   -1,   -1,  295,   -1,   -1,   -1,  316,  300,  318,  319,
-   -1,  304,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,  316,  334,  318,   -1,   -1,   -1,  322,
-   -1,  341,   -1,   -1,  344,  345,   -1,  330,  331,   -1,
-   -1,  334,   -1,   -1,  337,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,  366,  367,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  256,   -1,  417,  418,  419,  420,   -1,
+   -1,  264,  265,   -1,  267,   -1,  428,  270,  271,   -1,
+   -1,   -1,  275,  276,  277,   -1,  279,   -1,   -1,  265,
+   -1,  267,  285,   -1,  270,  288,   -1,   -1,   -1,  275,
+   -1,   -1,  295,  279,   -1,   -1,   -1,  300,   -1,  302,
+  303,  304,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,
+   -1,   -1,   -1,  316,  300,  318,  319,   -1,  304,  322,
+   -1,   -1,  325,   -1,  327,   -1,  329,  330,  331,  332,
+  316,  334,  318,   -1,  337,   -1,  322,   -1,  341,   -1,
+   -1,  344,  345,   -1,  330,  331,   -1,   -1,  334,   -1,
+   -1,  337,   -1,   -1,   -1,   -1,  359,  360,  361,   -1,
+  363,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  371,   -1,
+   -1,   -1,   -1,   -1,  377,  378,  379,  380,   -1,   -1,
+   -1,  384,   -1,  386,   -1,   -1,  372,   -1,   -1,  392,
+  393,   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,   -1,
+  267,   -1,   -1,  270,  271,   -1,   -1,   -1,  275,  276,
+  277,   -1,  279,   -1,  417,  418,  419,  420,  285,   -1,
+   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,
+   -1,   -1,  418,  300,   -1,  302,  303,  304,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,
+   -1,  318,  319,   -1,   -1,  322,   -1,   -1,  325,   -1,
+  327,   -1,  329,  330,  331,  332,   -1,  334,   -1,   -1,
+   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,  345,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  256,   -1,   -1,   -1,  416,  417,  418,  419,
-  264,  265,   -1,  267,   -1,   -1,  270,  271,   -1,  256,
-   -1,  275,  276,  277,  417,  279,   -1,   -1,  265,   -1,
-  267,  285,   -1,  270,  288,   -1,   -1,   -1,  275,   -1,
-   -1,  295,  279,   -1,   -1,   -1,  300,   -1,  302,  303,
-  304,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,
-   -1,   -1,  316,  300,  318,  319,  320,  304,  322,   -1,
-   -1,  325,   -1,  327,   -1,  329,  330,  331,  332,  316,
-  334,  318,   -1,   -1,   -1,  322,   -1,  341,   -1,   -1,
-  344,  345,   -1,  330,  331,   -1,   -1,  334,   -1,   -1,
-  337,   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,
-   -1,   -1,  366,   -1,   -1,   -1,  370,   -1,   -1,   -1,
-   -1,   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,
-   -1,  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,
-   -1,   -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,
-   -1,  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,
-  279,   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,
-   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,
-  417,  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,
-  319,   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,
-  329,  330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,
-   -1,   -1,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,
+   -1,   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,
+  367,   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,   -1,
+  377,  378,  379,  380,   -1,   -1,   -1,  384,   -1,  386,
+   -1,   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  360,  361,  362,   -1,   -1,   -1,  366,  367,   -1,
-   -1,  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,
-  379,   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,
-   -1,   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,
+  417,  418,  419,  420,   -1,   -1,  264,  265,   -1,  267,
+   -1,  428,  270,  271,   -1,   -1,   -1,  275,  276,  277,
+   -1,  279,   -1,   -1,  265,   -1,  267,  285,   -1,  270,
+  288,   -1,   -1,   -1,  275,   -1,   -1,  295,  279,   -1,
+   -1,   -1,  300,   -1,  302,  303,  304,  288,   -1,   -1,
+   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,  316,  300,
+  318,  319,   -1,  304,  322,   -1,   -1,  325,   -1,  327,
+   -1,  329,  330,  331,  332,  316,  334,  318,   -1,   -1,
+   -1,  322,   -1,  341,   -1,   -1,  344,  345,   -1,  330,
+  331,   -1,   -1,  334,   -1,   -1,  337,   -1,   -1,   -1,
+   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,  367,
+   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,   -1,  377,
+  378,  379,  380,   -1,   -1,   -1,  384,   -1,  386,  370,
+   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  256,   -1,  416,  417,  418,
-  419,   -1,   -1,  264,  265,   -1,  267,   -1,  427,  270,
-  271,   -1,  256,   -1,  275,  276,  277,   -1,  279,   -1,
+   -1,   -1,   -1,   -1,   -1,  256,   -1,   -1,   -1,  417,
+  418,  419,  420,  264,  265,   -1,  267,   -1,   -1,  270,
+  271,   -1,   -1,   -1,  275,  276,  277,  418,  279,   -1,
    -1,  265,   -1,  267,  285,   -1,  270,  288,   -1,   -1,
    -1,  275,   -1,   -1,  295,  279,   -1,   -1,   -1,  300,
    -1,  302,  303,  304,  288,   -1,   -1,   -1,   -1,   -1,
    -1,  295,   -1,   -1,   -1,  316,  300,  318,  319,   -1,
   304,  322,   -1,   -1,  325,   -1,  327,   -1,  329,  330,
-  331,  332,  316,  334,  318,   -1,  337,   -1,  322,   -1,
+  331,  332,  316,  334,  318,   -1,   -1,   -1,  322,   -1,
   341,   -1,   -1,  344,  345,   -1,  330,  331,   -1,   -1,
-  334,   -1,   -1,  337,   -1,   -1,   -1,   -1,   -1,  360,
-  361,  362,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  370,
-   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,   -1,
-   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,   -1,
-  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,
-   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,  275,
-  276,  277,   -1,  279,   -1,  416,  417,  418,  419,  285,
-   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,
-   -1,   -1,   -1,  417,  300,   -1,  302,  303,  304,   -1,
+  334,   -1,   -1,  337,   -1,   -1,   -1,   -1,  359,  360,
+  361,   -1,  363,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  371,   -1,   -1,   -1,   -1,   -1,  377,  378,  379,  380,
+   -1,   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,
+   -1,  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,  325,
-   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,   -1,
-   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,  345,
+   -1,   -1,  256,   -1,   -1,   -1,  417,  418,  419,  420,
+  264,  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,
+   -1,  275,  276,  277,  418,  279,   -1,   -1,   -1,   -1,
+   -1,  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,
+   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,
+  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,
+   -1,  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,
+  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,
+  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  359,  360,  361,   -1,  363,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  371,   -1,   -1,
+   -1,   -1,   -1,  377,  378,  379,  380,   -1,   -1,   -1,
+  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,  392,  393,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,   -1,
-  366,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,   -1,
-  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,  385,
-   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  256,   -1,
-  416,  417,  418,  419,   -1,   -1,  264,  265,   -1,  267,
-   -1,  427,  270,  271,   -1,   -1,   -1,  275,  276,  277,
-   -1,  279,   -1,   -1,  265,   -1,  267,  285,   -1,  270,
-  288,   -1,   -1,   -1,  275,   -1,   -1,  295,  279,   -1,
-   -1,   -1,  300,   -1,  302,  303,  304,  288,   -1,   -1,
-   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,  316,  300,
-  318,  319,   -1,  304,  322,   -1,   -1,  325,   -1,  327,
-   -1,  329,  330,  331,  332,  316,  334,  318,   -1,   -1,
-   -1,  322,   -1,  341,   -1,   -1,  344,  345,   -1,  330,
-  331,   -1,   -1,  334,   -1,   -1,  337,   -1,   -1,   -1,
-   -1,   -1,  360,  361,  362,   -1,   -1,   -1,  366,   -1,
-   -1,   -1,  370,   -1,   -1,   -1,   -1,   -1,  376,  377,
-  378,  379,   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,
-  371,   -1,   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  417,  418,  419,  420,  261,   -1,   -1,
+   -1,  265,   -1,  267,   -1,   -1,  270,   -1,  272,  273,
+   -1,  275,   -1,  277,   -1,  279,   -1,  281,  282,  283,
+  284,   -1,   -1,  287,  288,   -1,   -1,   -1,   -1,  293,
+   -1,  295,  296,  297,   -1,   -1,  300,   -1,  302,   -1,
+  304,   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,
+   -1,   -1,  316,  317,  318,   -1,   -1,  321,  322,  323,
+   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,   -1,  333,
+  334,   -1,  336,  337,  338,   -1,   -1,   -1,  342,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  256,   -1,   -1,   -1,  416,  417,
-  418,  419,  264,  265,   -1,  267,   -1,   -1,  270,  271,
-   -1,   -1,   -1,  275,  276,  277,  417,  279,   -1,   -1,
-  265,   -1,  267,  285,   -1,  270,  288,   -1,   -1,   -1,
-  275,   -1,   -1,  295,  279,   -1,   -1,   -1,  300,   -1,
-  302,  303,  304,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,  316,  300,  318,  319,   -1,  304,
-  322,   -1,   -1,  325,   -1,  327,   -1,  329,  330,  331,
-  332,  316,  334,  318,   -1,   -1,   -1,  322,   -1,  341,
-   -1,   -1,  344,  345,   -1,  330,  331,   -1,   -1,  334,
-   -1,   -1,  337,   -1,   -1,   -1,   -1,   -1,  360,  361,
-  362,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  370,   -1,
-   -1,   -1,   -1,   -1,  376,  377,  378,  379,   -1,   -1,
-   -1,  383,   -1,  385,  369,   -1,   -1,   -1,   -1,  391,
-  392,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  261,   -1,  362,   -1,
+  265,   -1,  267,   -1,  368,  270,   -1,  272,  273,   -1,
+  275,   -1,  277,  377,  279,   -1,  281,  282,  283,  284,
+   -1,   -1,  287,  288,   -1,   -1,   -1,   -1,  293,   -1,
+  295,  296,  297,   -1,   -1,  300,   -1,  302,   -1,  304,
+   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,
+   -1,  316,  317,  318,  418,   -1,  321,  322,  323,   -1,
+   -1,   -1,   -1,   -1,   -1,  330,  331,   -1,  333,  334,
+   -1,  336,  337,  338,   -1,   -1,   -1,  342,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  261,   -1,  362,   -1,  265,
+   -1,  267,   -1,  368,  270,   -1,  272,  273,   -1,  275,
+   -1,  277,  377,  279,   -1,  281,  282,  283,  284,   -1,
+   -1,  287,  288,   -1,   -1,   -1,   -1,  293,   -1,  295,
+  296,  297,   -1,   -1,  300,   -1,  302,   -1,  304,   -1,
+   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,
+  316,  317,  318,  418,   -1,  321,  322,  323,   -1,   -1,
+   -1,   -1,   -1,   -1,  330,  331,   -1,  333,  334,   -1,
+  336,  337,  338,   -1,   -1,   -1,  342,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  256,   -1,   -1,   -1,  416,  417,  418,  419,  264,  265,
+   -1,   -1,   -1,   -1,  261,   -1,  362,   -1,  265,   -1,
+  267,   -1,  368,  270,   -1,  272,  273,   -1,  275,   -1,
+  277,  377,  279,   -1,  281,  282,  283,  284,   -1,   -1,
+  287,  288,   -1,   -1,   -1,   -1,  293,   -1,  295,  296,
+  297,   -1,   -1,  300,   -1,  302,   -1,  304,   -1,   -1,
+  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,  316,
+  317,  318,  418,   -1,  321,  322,  323,   -1,   -1,   -1,
+   -1,   -1,   -1,  330,  331,   -1,  333,  334,   -1,  336,
+  337,  338,   -1,   -1,   -1,  342,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  261,   -1,  362,   -1,  265,   -1,  267,
+   -1,  368,  270,   -1,  272,  273,   -1,  275,   -1,  277,
+  377,  279,   -1,  281,  282,  283,  284,   -1,   -1,  287,
+  288,   -1,   -1,   -1,   -1,  293,   -1,  295,  296,  297,
+   -1,   -1,  300,   -1,  302,   -1,  304,   -1,   -1,  307,
+   -1,  309,  310,  311,  312,   -1,   -1,   -1,  316,  317,
+  318,  418,   -1,  321,  322,  323,   -1,   -1,   -1,   -1,
+   -1,   -1,  330,  331,   -1,  333,  334,   -1,  336,  337,
+  338,   -1,   -1,   -1,  342,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  261,   -1,   -1,
+   -1,  265,   -1,  267,  362,   -1,  270,   -1,  272,  273,
+  368,  275,   -1,  277,   -1,  279,   -1,  281,  282,  283,
+  284,   -1,   -1,  287,  288,   -1,   -1,   -1,   -1,  293,
+   -1,  295,  296,  297,   -1,   -1,  300,   -1,  302,  261,
+  304,   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,
+   -1,   -1,  316,  317,  318,   -1,   -1,  321,  322,  323,
+  418,   -1,  284,   -1,   -1,   -1,  330,  331,   -1,  333,
+  334,  261,  336,  337,  338,  297,   -1,   -1,  342,   -1,
+  302,   -1,   -1,  305,   -1,  307,   -1,  309,  310,  311,
+  312,   -1,   -1,   -1,  284,  317,   -1,   -1,  362,  321,
+   -1,   -1,   -1,  325,  368,   -1,   -1,  297,   -1,  261,
+   -1,  333,  302,   -1,  336,   -1,  338,  307,   -1,  309,
+  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,
+   -1,  321,  284,   -1,   -1,  357,   -1,   -1,   -1,  261,
+  362,   -1,   -1,  333,   -1,  297,  336,  369,  338,  371,
+  302,  373,   -1,  305,  418,  307,   -1,  309,  310,  311,
+  312,   -1,  284,   -1,  386,  317,   -1,   -1,   -1,  321,
+   -1,   -1,  362,  325,   -1,  297,   -1,   -1,   -1,   -1,
+  302,  333,   -1,   -1,  336,  307,  338,  309,  310,  311,
+  312,   -1,   -1,   -1,   -1,  317,  418,   -1,   -1,  321,
+   -1,   -1,   -1,  325,   -1,   -1,  264,  265,   -1,  267,
+  362,  333,  270,  271,  336,   -1,  338,  275,  276,  277,
+   -1,  279,   -1,   -1,   -1,   -1,   -1,  285,  418,   -1,
+  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,
+  362,   -1,  300,   -1,  302,  303,  304,   -1,  306,   -1,
+   -1,   -1,   -1,   -1,   -1,  313,   -1,   -1,  316,   -1,
+  318,  319,   -1,   -1,  322,   -1,  418,  325,   -1,  327,
+   -1,  329,  330,  331,  332,   -1,  334,   -1,   -1,   -1,
+   -1,   -1,   -1,  341,   -1,   -1,  344,  345,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,  418,   -1,   -1,   -1,
+   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  371,  372,   -1,  374,   -1,   -1,  377,
+  378,  379,  380,   -1,   -1,   -1,  384,   -1,  386,   -1,
+   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,
+   -1,   -1,  264,  265,   -1,  267,   -1,   -1,  270,  271,
+   -1,   -1,   -1,  275,  276,  277,   -1,  279,   -1,  417,
+  418,  419,  420,  285,   -1,   -1,  288,   -1,   -1,   -1,
+   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,
+  302,  303,  304,   -1,  306,   -1,   -1,   -1,   -1,   -1,
+   -1,  313,   -1,   -1,  316,   -1,  318,  319,   -1,   -1,
+  322,   -1,   -1,  325,   -1,  327,   -1,  329,  330,  331,
+  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,
+   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  371,
+   -1,   -1,  374,   -1,   -1,  377,  378,  379,  380,   -1,
+   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,
+  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,
    -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,  275,
-  276,  277,  417,  279,   -1,   -1,   -1,   -1,   -1,  285,
+  276,  277,   -1,  279,   -1,  417,  418,  419,  420,  285,
    -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,
    -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  262,   -1,   -1,   -1,
+  306,   -1,   -1,   -1,   -1,   -1,   -1,  313,   -1,   -1,
   316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,  325,
    -1,  327,   -1,  329,  330,  331,  332,   -1,  334,   -1,
    -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,  345,
-   -1,   -1,  298,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,   -1,
-  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,  385,
-   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  416,  417,  418,  419,  370,  371,  372,  373,   -1,   -1,
-   -1,  377,  378,   -1,   -1,  381,  382,  383,  384,  385,
-  386,  387,  388,  389,   -1,  391,  392,  393,  394,  395,
-  396,  397,  398,  399,  400,  401,  402,  403,  404,  405,
-  406,  407,  408,  409,  410,  411,  412,   -1,  261,   -1,
-   -1,   -1,  265,  419,  267,   -1,  422,  270,   -1,  272,
-  273,   -1,  275,   -1,  277,   -1,  279,   -1,  281,  282,
-  283,  284,   -1,   -1,  287,  288,   -1,   -1,   -1,   -1,
-  293,   -1,  295,  296,  297,   -1,   -1,  300,   -1,  302,
-   -1,  304,   -1,   -1,  307,   -1,  309,  310,  311,  312,
-   -1,   -1,   -1,  316,  317,  318,   -1,   -1,  321,  322,
-  323,   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,   -1,
-  333,  334,   -1,  336,  337,  338,   -1,   -1,   -1,  342,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  261,
-   -1,   -1,   -1,  265,   -1,  267,  359,   -1,  270,   -1,
-  272,  273,   -1,  275,  367,  277,   -1,  279,   -1,  281,
-  282,  283,  284,  376,   -1,  287,  288,   -1,   -1,   -1,
-   -1,  293,   -1,  295,  296,  297,   -1,   -1,  300,   -1,
-  302,   -1,  304,   -1,   -1,  307,   -1,  309,  310,  311,
-  312,   -1,   -1,   -1,  316,  317,  318,   -1,   -1,  321,
-  322,  323,   -1,   -1,  417,   -1,   -1,   -1,  330,  331,
-   -1,  333,  334,   -1,  336,  337,  338,   -1,   -1,   -1,
-  342,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  261,   -1,   -1,   -1,  265,   -1,  267,  359,   -1,  270,
-   -1,  272,  273,   -1,  275,  367,  277,   -1,  279,   -1,
-  281,  282,  283,  284,  376,   -1,  287,  288,   -1,   -1,
-   -1,   -1,  293,   -1,  295,  296,  297,   -1,   -1,  300,
-   -1,  302,   -1,  304,   -1,   -1,  307,   -1,  309,  310,
-  311,  312,   -1,   -1,   -1,  316,  317,  318,   -1,   -1,
-  321,  322,  323,   -1,   -1,  417,   -1,   -1,   -1,  330,
-  331,   -1,  333,  334,   -1,  336,  337,  338,   -1,   -1,
-   -1,  342,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  261,   -1,   -1,   -1,  265,   -1,  267,  359,   -1,
-  270,   -1,  272,  273,   -1,  275,  367,  277,   -1,  279,
-   -1,  281,  282,  283,  284,  376,   -1,  287,  288,   -1,
-   -1,   -1,   -1,  293,   -1,  295,  296,  297,   -1,   -1,
-  300,   -1,  302,   -1,  304,   -1,   -1,  307,   -1,  309,
-  310,  311,  312,   -1,   -1,   -1,  316,  317,  318,   -1,
-   -1,  321,  322,  323,   -1,   -1,  417,   -1,   -1,   -1,
-  330,  331,   -1,  333,  334,   -1,  336,  337,  338,   -1,
-   -1,   -1,  342,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  261,   -1,   -1,   -1,  265,   -1,  267,  359,
-   -1,  270,   -1,  272,  273,   -1,  275,  367,  277,   -1,
-  279,   -1,  281,  282,  283,  284,  376,   -1,  287,  288,
-   -1,   -1,   -1,   -1,  293,   -1,  295,  296,  297,   -1,
-   -1,  300,   -1,  302,   -1,  304,   -1,   -1,  307,   -1,
-  309,  310,  311,  312,   -1,   -1,   -1,  316,  317,  318,
-   -1,   -1,  321,  322,  323,   -1,   -1,  417,   -1,   -1,
-   -1,  330,  331,   -1,  333,  334,   -1,  336,  337,  338,
-   -1,   -1,   -1,  342,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  261,   -1,   -1,   -1,  265,   -1,  267,
-  359,   -1,  270,   -1,  272,  273,   -1,  275,  367,  277,
-   -1,  279,   -1,  281,  282,  283,  284,   -1,   -1,  287,
-  288,   -1,   -1,   -1,   -1,  293,   -1,  295,  296,  297,
-   -1,   -1,  300,   -1,  302,   -1,  304,  261,   -1,  307,
-   -1,  309,  310,  311,  312,   -1,   -1,   -1,  316,  317,
-  318,   -1,   -1,  321,  322,  323,   -1,   -1,  417,   -1,
-  284,   -1,  330,  331,   -1,  333,  334,   -1,  336,  337,
-  338,   -1,   -1,  297,  342,   -1,   -1,   -1,  302,   -1,
-   -1,  305,   -1,  307,   -1,  309,  310,  311,  312,   -1,
-   -1,  359,   -1,  317,   -1,   -1,   -1,  321,   -1,  367,
-   -1,  325,   -1,   -1,   -1,   -1,  261,   -1,   -1,  333,
-   -1,   -1,  336,   -1,  338,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  284,
-   -1,   -1,   -1,  357,   -1,  359,  261,   -1,   -1,   -1,
-   -1,   -1,  297,   -1,  368,   -1,  370,  302,  372,  417,
-  305,   -1,  307,   -1,  309,  310,  311,  312,   -1,  284,
-   -1,  385,  317,   -1,   -1,   -1,  321,   -1,   -1,   -1,
-  325,  261,  297,   -1,   -1,   -1,   -1,  302,  333,   -1,
-  305,  336,  307,  338,  309,  310,  311,  312,   -1,   -1,
-   -1,   -1,  317,  417,  284,   -1,  321,   -1,   -1,   -1,
-  325,  261,   -1,   -1,  359,   -1,   -1,  297,  333,   -1,
-   -1,  336,  302,  338,   -1,   -1,   -1,  307,   -1,  309,
-  310,  311,  312,   -1,  284,   -1,   -1,  317,   -1,   -1,
-   -1,  321,   -1,   -1,  359,  325,   -1,  297,   -1,   -1,
-   -1,   -1,  302,  333,   -1,   -1,  336,  307,  338,  309,
-  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,
-   -1,  321,  417,   -1,   -1,   -1,   -1,   -1,   -1,  359,
-   -1,   -1,   -1,  333,  264,  265,  336,  267,  338,   -1,
-  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,   -1,  417,   -1,   -1,  285,   -1,   -1,  288,  359,
-   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,   -1,  306,   -1,   -1,   -1,
-   -1,   -1,   -1,  313,   -1,   -1,  316,  417,  318,  319,
-   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,
-   -1,  341,   -1,   -1,  344,  345,   -1,  417,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  370,  371,   -1,  373,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,
-  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,
-  275,  276,  277,   -1,  279,   -1,  416,  417,  418,  419,
-  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
-   -1,  306,   -1,   -1,   -1,   -1,   -1,   -1,  313,   -1,
-   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,
-  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,
-   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,
-  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  370,   -1,   -1,  373,   -1,
-   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,
-  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,
-   -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
-  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,   -1,
-   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,   -1,  306,   -1,   -1,   -1,
-   -1,   -1,   -1,  313,   -1,   -1,  316,   -1,  318,  319,
-   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,
-   -1,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,
-  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,
-  275,  276,  277,   -1,  279,   -1,  416,  417,  418,  419,
-  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,
-  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,
-   -1,   -1,  337,   -1,   -1,   -1,  341,   -1,   -1,  344,
-  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,
-   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,
-  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,
+   -1,   -1,   -1,  359,  360,  361,   -1,  363,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,
+   -1,  377,  378,  379,  380,   -1,   -1,   -1,  384,   -1,
+  386,   -1,   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,
    -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
   270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,   -1,
+   -1,  417,  418,  419,  420,  285,   -1,   -1,  288,   -1,
    -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
   300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
    -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,
+  330,  331,  332,   -1,  334,   -1,   -1,  337,   -1,   -1,
    -1,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,
+  360,  361,   -1,  363,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  371,   -1,   -1,   -1,   -1,   -1,  377,  378,  379,
+  380,   -1,   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,
+   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,
+  264,  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,
+   -1,  275,  276,  277,   -1,  279,   -1,  417,  418,  419,
+  420,  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,
+   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,
+  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,
+   -1,  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,
+  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,
+  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  359,  360,  361,   -1,  363,
+   -1,   -1,   -1,   -1,  368,   -1,   -1,  371,   -1,   -1,
+   -1,   -1,   -1,  377,  378,  379,  380,   -1,   -1,   -1,
+  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,  392,  393,
+   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,   -1,  267,
+   -1,   -1,  270,  271,   -1,   -1,   -1,  275,  276,  277,
+   -1,  279,   -1,  417,  418,  419,  420,  285,   -1,   -1,
+  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,
+   -1,   -1,  300,   -1,  302,  303,  304,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,
+  318,  319,   -1,   -1,  322,   -1,   -1,  325,   -1,  327,
+   -1,  329,  330,  331,  332,   -1,  334,   -1,   -1,   -1,
+   -1,   -1,   -1,  341,   -1,   -1,  344,  345,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,   -1,  367,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,
-  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,
-  275,  276,  277,   -1,  279,   -1,  416,  417,  418,  419,
-  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,
-  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,
-   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,
-  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,
-   -1,  366,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,
-   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,
-  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,
-   -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
-  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,   -1,
-   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
-   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,
-   -1,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,
+   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,  367,
+   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,   -1,  377,
+  378,  379,  380,   -1,   -1,   -1,  384,   -1,  386,   -1,
+   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,
+   -1,   -1,  264,  265,   -1,  267,   -1,   -1,  270,  271,
+   -1,   -1,   -1,  275,  276,  277,   -1,  279,   -1,  417,
+  418,  419,  420,  285,   -1,   -1,  288,   -1,   -1,   -1,
+   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,
+  302,  303,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  316,   -1,  318,  319,   -1,   -1,
+  322,   -1,   -1,  325,   -1,  327,   -1,  329,  330,  331,
+  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,
+   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,   -1,   -1,   -1,  367,   -1,   -1,   -1,  371,
+   -1,   -1,   -1,   -1,   -1,  377,  378,  379,  380,   -1,
+   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,
+  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,
+   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,  275,
+  276,  277,   -1,  279,   -1,  417,  418,  419,  420,  285,
+   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,
+   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,  366,   -1,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,
-  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,
-  275,  276,  277,   -1,  279,   -1,  416,  417,  418,  419,
-  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
+  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,  325,
+   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,   -1,
+   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,  345,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,
-  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,
-   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,
-  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,
-   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,
-  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,
+   -1,   -1,   -1,  359,  360,  361,   -1,  363,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,
+   -1,  377,  378,  379,  380,   -1,   -1,   -1,  384,   -1,
+  386,   -1,   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,
    -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
   270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,   -1,
+   -1,  417,  418,  419,  420,  285,   -1,   -1,  288,   -1,
    -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
   300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
    -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
   330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,
    -1,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,
+  360,  361,   -1,  363,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  371,   -1,   -1,   -1,   -1,   -1,  377,  378,  379,
+  380,   -1,   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,
+   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,
+  264,  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,
+   -1,  275,  276,  277,   -1,  279,   -1,  417,  418,  419,
+  420,  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,
+   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,
+  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,
+   -1,  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,
+  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,
+  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  359,  360,  361,   -1,  363,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  371,   -1,   -1,
+   -1,   -1,   -1,  377,  378,  379,  380,   -1,   -1,   -1,
+  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,  392,  393,
+   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,   -1,  267,
+   -1,   -1,  270,  271,   -1,   -1,   -1,  275,  276,  277,
+   -1,  279,   -1,  417,  418,  419,  420,  285,   -1,   -1,
+  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,
+   -1,   -1,  300,   -1,  302,  303,  304,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,
+  318,  319,   -1,   -1,  322,   -1,   -1,  325,   -1,  327,
+   -1,  329,  330,  331,  332,   -1,  334,   -1,   -1,   -1,
+   -1,   -1,   -1,  341,   -1,   -1,  344,  345,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,
-  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,
-  275,  276,  277,   -1,  279,   -1,  416,  417,  418,  419,
-  285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,
-  325,   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,
-   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,
-  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,
-   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,
-  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,
-   -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
-  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,   -1,
-   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
-   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,
-   -1,  341,   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,
+   -1,  359,  360,  361,   -1,  363,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  371,   -1,   -1,   -1,   -1,   -1,  377,
+  378,  379,  380,   -1,   -1,   -1,  384,   -1,  386,   -1,
+   -1,   -1,   -1,   -1,  392,  393,   -1,   -1,   -1,   -1,
+   -1,   -1,  264,  265,   -1,  267,   -1,   -1,  270,  271,
+   -1,   -1,   -1,  275,  276,  277,   -1,  279,   -1,  417,
+  418,  419,  420,  285,   -1,   -1,  288,   -1,   -1,   -1,
+   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,
+  302,  303,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  316,   -1,  318,  319,   -1,   -1,
+  322,   -1,   -1,  325,   -1,  327,   -1,  329,  330,  331,
+  332,   -1,  334,   -1,   -1,   -1,   -1,   -1,   -1,  341,
+   -1,   -1,  344,  345,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  371,
+   -1,   -1,   -1,   -1,   -1,  377,  378,  379,  380,   -1,
+   -1,   -1,  384,   -1,  386,   -1,   -1,   -1,   -1,   -1,
+  392,  393,   -1,   -1,   -1,   -1,   -1,   -1,  264,  265,
+   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,  275,
+  276,  277,   -1,  279,   -1,  417,  418,  419,  420,  285,
+   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,  295,
+   -1,  261,   -1,   -1,  300,   -1,  302,  303,  304,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  360,  361,  362,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-  370,   -1,   -1,   -1,   -1,   -1,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,   -1,   -1,   -1,
-   -1,  391,  392,   -1,   -1,   -1,   -1,   -1,   -1,  264,
-  265,   -1,  267,   -1,   -1,  270,  271,   -1,   -1,   -1,
-  275,  276,  277,   -1,  279,   -1,  416,  417,  418,  419,
+  316,   -1,  318,  319,  284,   -1,  322,   -1,   -1,  325,
+   -1,  327,   -1,  329,  330,  331,  332,  297,  334,   -1,
+   -1,   -1,  302,   -1,   -1,   -1,   -1,  307,   -1,  309,
+  310,  311,  312,   -1,   -1,  315,   -1,  317,   -1,   -1,
+   -1,  321,   -1,  359,  360,  361,   -1,  363,   -1,   -1,
+   -1,   -1,   -1,  333,   -1,  371,  336,   -1,  338,   -1,
+   -1,  377,  378,  379,  380,   -1,   -1,   -1,  384,   -1,
+  386,   -1,  264,  265,   -1,  267,  392,  393,  270,  271,
+   -1,   -1,  362,  275,  276,  277,   -1,  279,  368,  369,
+   -1,   -1,   -1,  285,   -1,   -1,  288,   -1,   -1,   -1,
+  261,  417,  418,  295,  420,   -1,   -1,   -1,  300,   -1,
+  302,  303,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,  284,  316,   -1,  318,  319,   -1,   -1,
+  322,   -1,   -1,  325,   -1,  327,  297,  329,  330,  331,
+  332,  302,  334,   -1,   -1,   -1,  307,   -1,  309,  310,
+  311,  312,   -1,   -1,  315,   -1,  317,   -1,   -1,   -1,
+  321,   -1,   -1,   -1,   -1,   -1,   -1,  359,  360,  361,
+   -1,  363,  333,   -1,   -1,  336,   -1,  338,   -1,  371,
+  263,   -1,  265,   -1,  267,  377,   -1,  270,  380,  272,
+  273,   -1,  275,   -1,  277,   -1,  279,   -1,  281,  282,
+  283,  362,   -1,   -1,  287,  288,   -1,  368,   -1,   -1,
+  293,   -1,  295,  296,   -1,   -1,   -1,  300,   -1,   -1,
+   -1,  304,   -1,   -1,   -1,  417,  418,   -1,  420,   -1,
+   -1,   -1,  315,  316,   -1,  318,   -1,   -1,   -1,  322,
+  323,   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,  264,
+  265,  334,  267,   -1,  337,  270,  271,   -1,   -1,  342,
+  275,  276,  277,   -1,  279,   -1,   -1,   -1,   -1,   -1,
   285,   -1,   -1,  288,   -1,   -1,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,  302,  303,  304,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  295,  364,  365,   -1,   -1,  300,   -1,  302,  303,  304,
+   -1,   -1,   -1,   -1,  377,   -1,   -1,   -1,   -1,   -1,
    -1,  316,   -1,  318,  319,   -1,   -1,  322,   -1,   -1,
   325,   -1,  327,   -1,  329,  330,  331,  332,   -1,  334,
-   -1,   -1,   -1,   -1,   -1,   -1,  341,   -1,   -1,  344,
-  345,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  360,  361,  362,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  370,   -1,   -1,   -1,   -1,
-   -1,  376,  377,  378,  379,   -1,   -1,   -1,  383,   -1,
-  385,   -1,   -1,   -1,   -1,   -1,  391,  392,   -1,   -1,
-   -1,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
-  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  416,  417,  418,  419,  285,   -1,   -1,  288,   -1,
-   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
-   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,   -1,  265,   -1,  267,   -1,
-   -1,  270,   -1,  272,   -1,   -1,  275,   -1,   -1,   -1,
-  279,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  288,
-  360,  361,  362,   -1,   -1,   -1,  295,   -1,   -1,   -1,
-  370,  300,   -1,  302,   -1,  304,  376,  377,  378,  379,
-   -1,   -1,   -1,  383,   -1,  385,   -1,  316,   -1,  318,
-   -1,  391,  392,  322,  323,   -1,   -1,   -1,   -1,   -1,
-   -1,  330,  331,   -1,   -1,  334,   -1,   -1,  337,   -1,
-   -1,  263,   -1,  265,   -1,  267,  416,  417,  270,  419,
-  272,  273,   -1,  275,   -1,  277,   -1,  279,   -1,  281,
-  282,  283,   -1,   -1,   -1,  287,  288,   -1,   -1,   -1,
-   -1,  293,   -1,  295,  296,   -1,   -1,   -1,  300,   -1,
-   -1,   -1,  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,  315,  316,   -1,  318,   -1,   -1,   -1,
-  322,  323,   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,
-   -1,   -1,  334,   -1,   -1,  337,   -1,   -1,  417,   -1,
-  342,   -1,   -1,   -1,  264,  265,   -1,  267,   -1,   -1,
-  270,  271,   -1,   -1,   -1,  275,  276,  277,   -1,  279,
-   -1,  363,  364,   -1,   -1,  285,   -1,   -1,  288,   -1,
-   -1,   -1,   -1,   -1,  376,  295,   -1,   -1,   -1,   -1,
-  300,   -1,  302,  303,  304,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,  319,
-   -1,   -1,  322,   -1,   -1,  325,   -1,  327,   -1,  329,
-  330,  331,  332,   -1,  334,  417,  265,  337,  267,   -1,
-   -1,  270,   -1,  272,  273,   -1,  275,   -1,  277,   -1,
-  279,   -1,  281,  282,  283,   -1,   -1,   -1,  287,  288,
-  360,  361,  362,   -1,  293,   -1,  295,  296,   -1,   -1,
-  370,  300,   -1,   -1,   -1,  304,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,
-   -1,   -1,   -1,  322,  323,   -1,   -1,   -1,   -1,   -1,
-   -1,  330,  331,   -1,   -1,  334,   -1,   -1,  337,   -1,
-   -1,   -1,   -1,  342,   -1,   -1,  416,  417,  265,   -1,
-  267,   -1,   -1,  270,   -1,  272,  273,   -1,  275,   -1,
-  277,   -1,  279,   -1,  281,  282,  283,   -1,   -1,   -1,
-  287,  288,   -1,   -1,   -1,   -1,  293,  376,  295,  296,
-  265,   -1,  267,  300,   -1,  270,   -1,  304,  273,   -1,
-  275,   -1,  277,   -1,  279,   -1,  281,  282,  283,  316,
-   -1,  318,  287,  288,   -1,  322,  323,   -1,  293,   -1,
-  295,   -1,   -1,  330,  331,  300,   -1,  334,  417,  304,
-  337,   -1,   -1,   -1,   -1,  342,   -1,   -1,   -1,   -1,
-   -1,  316,   -1,  318,   -1,   -1,   -1,  322,   -1,   -1,
-   -1,   -1,   -1,   -1,   -1,  330,  331,   -1,  265,  334,
-  267,   -1,  337,  270,   -1,   -1,  273,  342,  275,   -1,
-  277,   -1,  279,   -1,  281,  282,  283,   -1,   -1,   -1,
-  287,  288,   -1,   -1,   -1,   -1,  293,   -1,  295,   -1,
-  265,   -1,  267,  300,   -1,  270,   -1,  304,   -1,   -1,
-  275,  376,   -1,   -1,  279,   -1,   -1,   -1,   -1,  316,
-  417,  318,   -1,  288,   -1,  322,   -1,   -1,   -1,   -1,
-  295,   -1,   -1,  330,  331,  300,   -1,  334,   -1,  304,
-  337,  306,   -1,  308,  265,  342,  267,   -1,  313,  270,
-   -1,  316,  417,  318,  275,   -1,   -1,  322,  279,   -1,
-  325,   -1,   -1,   -1,   -1,  330,  331,  288,   -1,  334,
-   -1,   -1,  337,   -1,  295,   -1,   -1,   -1,   -1,  300,
-   -1,   -1,   -1,  304,  265,  306,  267,  308,   -1,  270,
-   -1,   -1,  313,   -1,  275,  316,   -1,  318,  279,   -1,
-   -1,  322,   -1,   -1,  325,   -1,  371,  288,   -1,  330,
-  331,   -1,   -1,  334,  295,   -1,  337,   -1,   -1,  300,
-  417,   -1,   -1,  304,   -1,  306,   -1,  308,  265,   -1,
-  267,   -1,  313,  270,   -1,  316,   -1,  318,  275,   -1,
-   -1,  322,  279,   -1,  325,   -1,   -1,   -1,  369,  330,
-  331,  288,  417,  334,   -1,   -1,  337,   -1,  295,   -1,
-   -1,   -1,   -1,  300,   -1,   -1,   -1,  304,   -1,  306,
-   -1,   -1,   -1,   -1,   -1,   -1,  313,   -1,   -1,  316,
-   -1,  318,   -1,   -1,   -1,  322,   -1,   -1,  325,   -1,
-   -1,   -1,   -1,  330,  331,   -1,  417,  334,   -1,  265,
-  337,  267,   -1,   -1,  270,   -1,   -1,   -1,   -1,  275,
-  265,   -1,  267,  279,   -1,  270,   -1,  283,   -1,   -1,
-  275,   -1,  288,   -1,  279,   -1,   -1,  293,   -1,  295,
-   -1,   -1,   -1,  288,  300,   -1,  417,   -1,  304,  305,
-  295,   -1,   -1,   -1,   -1,  300,   -1,   -1,   -1,  304,
-  316,   -1,  318,   -1,   -1,   -1,  322,   -1,   -1,   -1,
-   -1,  316,   -1,  318,  330,  331,   -1,  322,  334,   -1,
-   -1,   -1,   -1,   -1,   -1,  330,  331,   -1,   -1,  334,
-  417,  265,  337,  267,   -1,   -1,  270,   -1,   -1,   -1,
-   -1,  275,  265,   -1,  267,  279,   -1,  270,   -1,   -1,
-   -1,   -1,  275,   -1,  288,   -1,  279,   -1,   -1,   -1,
-   -1,  295,   -1,   -1,   -1,  288,  300,   -1,   -1,   -1,
-  304,   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,   -1,
-   -1,  304,  316,   -1,  318,   -1,   -1,   -1,  322,   -1,
-   -1,   -1,   -1,  316,   -1,  318,  330,  331,   -1,  322,
-  334,  417,   -1,  337,   -1,   -1,   -1,  330,  331,   -1,
-   -1,  334,  417,  265,  337,  267,   -1,   -1,  270,   -1,
-   -1,   -1,   -1,  275,  265,   -1,  267,  279,   -1,  270,
-   -1,   -1,   -1,   -1,  275,   -1,  288,   -1,  279,   -1,
-   -1,   -1,   -1,  295,   -1,   -1,   -1,  288,  300,   -1,
-   -1,   -1,  304,   -1,  295,   -1,   -1,   -1,   -1,  300,
-   -1,   -1,   -1,  304,  316,   -1,  318,   -1,   -1,   -1,
-  322,   -1,   -1,   -1,   -1,  316,   -1,  318,  330,  331,
-   -1,  322,  334,  417,   -1,  337,   -1,   -1,   -1,  330,
-  331,   -1,   -1,  334,  417,  265,  337,  267,   -1,   -1,
-  270,   -1,   -1,   -1,   -1,  275,  265,   -1,  267,  279,
-   -1,  270,   -1,   -1,   -1,   -1,  275,   -1,  288,   -1,
-  279,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,  288,
-  300,   -1,   -1,   -1,  304,   -1,  295,   -1,   -1,   -1,
-   -1,  300,   -1,   -1,   -1,  304,  316,   -1,  318,   -1,
-   -1,   -1,  322,   -1,   -1,   -1,   -1,  316,   -1,  318,
-  330,  331,   -1,  322,  334,  417,   -1,  337,   -1,   -1,
-   -1,  330,  331,   -1,   -1,  334,  417,  265,  337,  267,
-   -1,   -1,  270,   -1,   -1,   -1,   -1,  275,  265,   -1,
-  267,  279,   -1,  270,   -1,   -1,   -1,   -1,  275,   -1,
-  288,   -1,  279,   -1,   -1,   -1,   -1,  295,   -1,   -1,
-   -1,  288,  300,   -1,   -1,   -1,  304,   -1,  295,   -1,
-   -1,   -1,   -1,  300,   -1,   -1,   -1,  304,  316,   -1,
-  318,   -1,   -1,   -1,  322,   -1,   -1,   -1,   -1,  316,
-   -1,  318,  330,  331,   -1,  322,  334,  417,   -1,  337,
-   -1,   -1,   -1,  330,  331,   -1,   -1,  334,  417,  265,
-  337,  267,   -1,   -1,  270,   -1,   -1,   -1,   -1,  275,
-  265,   -1,  267,  279,   -1,  270,   -1,   -1,   -1,   -1,
-  275,   -1,  288,   -1,  279,   -1,   -1,   -1,   -1,  295,
-   -1,   -1,   -1,  288,  300,   -1,   -1,   -1,  304,   -1,
-  295,   -1,   -1,   -1,   -1,  300,   -1,   -1,   -1,  304,
-  316,   -1,  318,   -1,   -1,   -1,  322,   -1,   -1,   -1,
-   -1,  316,   -1,  318,  330,  331,   -1,  322,  334,  417,
-   -1,  337,   -1,   -1,   -1,  330,  331,   -1,   -1,  334,
-  417,  265,  337,  267,   -1,   -1,  270,   -1,   -1,   -1,
-   -1,  275,   -1,   -1,   -1,  279,   -1,   -1,   -1,   -1,
-   -1,   -1,   -1,   -1,  288,   -1,   -1,   -1,  261,   -1,
-   -1,  295,   -1,   -1,   -1,   -1,  300,   -1,   -1,  272,
-  304,   -1,   -1,   -1,  277,   -1,   -1,   -1,  281,   -1,
-   -1,  284,  316,   -1,  318,   -1,   -1,   -1,  322,   -1,
-   -1,   -1,   -1,  296,  297,   -1,  330,  331,  301,  302,
-  334,  417,   -1,  337,  307,   -1,  309,  310,  311,  312,
-   -1,   -1,  417,   -1,  317,   -1,   -1,   -1,  321,   -1,
-  323,   -1,   -1,   -1,   -1,   -1,  261,   -1,   -1,   -1,
-  333,   -1,  335,  336,   -1,  338,   -1,  272,   -1,  342,
-   -1,   -1,  277,   -1,   -1,   -1,  281,   -1,   -1,  284,
-   -1,   -1,   -1,   -1,   -1,   -1,  359,   -1,   -1,   -1,
-   -1,  296,  297,   -1,  367,  368,  301,  302,   -1,  261,
-   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,
-   -1,   -1,  317,  417,   -1,   -1,  321,   -1,  323,   -1,
-   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,  333,   -1,
-   -1,  336,   -1,  338,   -1,  297,   -1,  342,   -1,   -1,
-  302,   -1,  261,   -1,  263,  307,   -1,  309,  310,  311,
-  312,   -1,   -1,  315,  359,  317,   -1,   -1,   -1,  321,
-   -1,   -1,  367,  368,   -1,  284,   -1,   -1,   -1,   -1,
-   -1,  333,   -1,   -1,  336,   -1,  338,   -1,  297,   -1,
-   -1,   -1,   -1,  302,   -1,   -1,   -1,   -1,  307,   -1,
-  309,  310,  311,  312,   -1,   -1,   -1,  359,  317,   -1,
-   -1,   -1,  321,   -1,   -1,  367,  368,   -1,   -1,   -1,
-  261,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,  338,
-   -1,  272,   -1,   -1,   -1,   -1,  277,   -1,   -1,   -1,
-  281,   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,
-  359,   -1,   -1,   -1,   -1,  296,  297,   -1,  367,  368,
-  301,  302,   -1,  261,   -1,   -1,  307,   -1,  309,  310,
-  311,  312,   -1,   -1,  272,   -1,  317,   -1,   -1,  277,
-  321,   -1,  323,  281,   -1,   -1,  284,   -1,   -1,   -1,
-   -1,   -1,  333,   -1,   -1,  336,   -1,  338,  296,  297,
-   -1,  342,   -1,  301,  302,   -1,  261,   -1,   -1,  307,
-   -1,  309,  310,  311,  312,   -1,   -1,   -1,  359,  317,
-   -1,   -1,   -1,  321,   -1,  323,  367,   -1,   -1,  284,
-   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,
-  338,  261,  297,   -1,  342,   -1,   -1,  302,   -1,   -1,
-   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,
-   -1,  359,  317,   -1,  284,   -1,  321,   -1,   -1,  367,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  297,  333,   -1,
-   -1,  336,  302,  338,   -1,   -1,   -1,  307,   -1,  309,
-  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,
-  261,  321,  263,   -1,  359,   -1,   -1,   -1,  363,  364,
-   -1,   -1,  367,  333,   -1,   -1,  336,   -1,  338,   -1,
-   -1,   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,
-  261,   -1,   -1,   -1,   -1,   -1,  297,   -1,   -1,  359,
-   -1,  302,   -1,  363,  364,   -1,  307,  367,  309,  310,
-  311,  312,   -1,  284,   -1,   -1,  317,   -1,   -1,   -1,
-  321,   -1,   -1,   -1,   -1,   -1,  297,   -1,   -1,   -1,
-   -1,  302,  333,   -1,   -1,  336,  307,  338,  309,  310,
-  311,  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,  261,
-  321,  263,   -1,   -1,   -1,   -1,   -1,   -1,  359,   -1,
-   -1,   -1,  333,   -1,   -1,  336,  367,  338,   -1,   -1,
-   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,  261,
-   -1,   -1,   -1,   -1,   -1,  297,   -1,   -1,  359,   -1,
-  302,   -1,  363,  364,   -1,  307,   -1,  309,  310,  311,
-  312,   -1,  284,  315,   -1,  317,   -1,   -1,   -1,  321,
-   -1,   -1,   -1,   -1,  261,  297,   -1,   -1,   -1,  301,
-  302,  333,   -1,   -1,  336,  307,  338,  309,  310,  311,
-  312,   -1,   -1,   -1,   -1,  317,   -1,  284,   -1,  321,
-   -1,   -1,   -1,   -1,   -1,   -1,   -1,  359,   -1,   -1,
-  297,  333,   -1,   -1,  336,  302,  338,   -1,   -1,   -1,
+   -1,   -1,  337,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  418,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  359,  360,  361,  265,   -1,  267,
+   -1,   -1,  270,   -1,  272,  273,  371,  275,   -1,  277,
+   -1,  279,   -1,  281,  282,  283,   -1,   -1,   -1,  287,
+  288,   -1,   -1,   -1,   -1,  293,   -1,  295,  296,   -1,
+   -1,   -1,  300,   -1,   -1,   -1,  304,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,
+  318,   -1,  417,  418,  322,  323,   -1,   -1,   -1,   -1,
+   -1,   -1,  330,  331,   -1,  265,  334,  267,   -1,  337,
+  270,   -1,  272,  273,  342,  275,   -1,  277,   -1,  279,
+   -1,  281,  282,  283,   -1,   -1,   -1,  287,  288,   -1,
+   -1,   -1,   -1,  293,   -1,  295,  296,   -1,   -1,   -1,
+  300,   -1,   -1,   -1,  304,   -1,   -1,   -1,   -1,  377,
+   -1,   -1,   -1,   -1,   -1,   -1,  316,   -1,  318,   -1,
+   -1,   -1,  322,  323,   -1,   -1,   -1,   -1,   -1,   -1,
+  330,  331,   -1,   -1,  334,   -1,   -1,  337,   -1,  265,
+   -1,  267,  342,   -1,  270,   -1,   -1,  273,   -1,  275,
+  418,  277,   -1,  279,   -1,  281,  282,  283,   -1,   -1,
+   -1,  287,  288,   -1,   -1,   -1,   -1,  293,   -1,  295,
+   -1,  265,   -1,  267,  300,   -1,  270,   -1,  304,  273,
+   -1,  275,   -1,  277,   -1,  279,   -1,  281,  282,  283,
+  316,   -1,  318,  287,  288,   -1,  322,   -1,   -1,  293,
+   -1,  295,   -1,   -1,  330,  331,  300,   -1,  334,   -1,
+  304,  337,   -1,   -1,   -1,  265,  342,  267,  418,   -1,
+  270,   -1,  316,   -1,  318,  275,   -1,   -1,  322,  279,
+   -1,   -1,   -1,   -1,   -1,   -1,  330,  331,  288,   -1,
+  334,   -1,   -1,  337,   -1,  295,   -1,  265,  342,  267,
+  300,  377,  270,   -1,  304,   -1,  306,  275,  308,   -1,
+   -1,  279,   -1,  313,   -1,   -1,  316,   -1,  318,   -1,
+  288,   -1,  322,   -1,   -1,  325,   -1,  295,   -1,   -1,
+  330,  331,  300,   -1,  334,   -1,  304,  337,  306,   -1,
+  308,  265,  418,  267,   -1,  313,  270,   -1,  316,   -1,
+  318,  275,   -1,   -1,  322,  279,   -1,  325,   -1,   -1,
+   -1,   -1,  330,  331,  288,   -1,  334,   -1,   -1,  337,
+   -1,  295,  372,  265,  418,  267,  300,   -1,  270,   -1,
+  304,   -1,  306,  275,  308,   -1,   -1,  279,   -1,  313,
+   -1,   -1,  316,   -1,  318,   -1,  288,   -1,  322,   -1,
+   -1,  325,  370,  295,   -1,   -1,  330,  331,  300,   -1,
+  334,   -1,  304,  337,  306,   -1,   -1,   -1,  418,   -1,
+   -1,  313,   -1,   -1,  316,   -1,  318,   -1,   -1,   -1,
+  322,   -1,   -1,  325,   -1,   -1,   -1,   -1,  330,  331,
+   -1,   -1,  334,   -1,  265,  337,  267,   -1,   -1,  270,
+  418,  272,   -1,   -1,  275,   -1,   -1,   -1,  279,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,  288,  265,   -1,
+  267,   -1,   -1,  270,  295,   -1,   -1,   -1,  275,  300,
+   -1,  302,  279,  304,   -1,   -1,  283,   -1,   -1,   -1,
+   -1,  288,   -1,   -1,  418,  316,  293,  318,  295,   -1,
+   -1,  322,  323,  300,   -1,   -1,   -1,  304,  305,  330,
+  331,   -1,   -1,  334,   -1,   -1,  337,   -1,  265,  316,
+  267,  318,   -1,  270,   -1,  322,  418,   -1,  275,   -1,
+   -1,   -1,  279,  330,  331,   -1,   -1,  334,   -1,   -1,
+   -1,  288,  265,   -1,  267,   -1,   -1,  270,  295,   -1,
+   -1,   -1,  275,  300,   -1,   -1,  279,  304,   -1,   -1,
+   -1,   -1,   -1,   -1,   -1,  288,   -1,   -1,   -1,  316,
+   -1,  318,  295,   -1,   -1,  322,   -1,  300,   -1,   -1,
+   -1,  304,   -1,  330,  331,   -1,   -1,  334,   -1,   -1,
+  337,   -1,   -1,  316,   -1,  318,  265,  418,  267,  322,
+   -1,  270,   -1,   -1,   -1,   -1,  275,  330,  331,   -1,
+  279,  334,   -1,  265,  337,  267,   -1,   -1,  270,  288,
+   -1,  418,   -1,  275,   -1,   -1,  295,  279,   -1,   -1,
+   -1,  300,   -1,   -1,   -1,  304,  288,   -1,   -1,   -1,
+   -1,   -1,   -1,  295,   -1,   -1,   -1,  316,  300,  318,
+   -1,   -1,  304,  322,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  330,  331,   -1,  316,  334,  318,  265,  337,  267,
+  322,  418,  270,   -1,   -1,   -1,   -1,  275,  330,  331,
+   -1,  279,  334,   -1,   -1,  337,   -1,   -1,   -1,   -1,
+  288,  265,   -1,  267,   -1,  418,  270,  295,   -1,   -1,
+   -1,  275,  300,   -1,   -1,  279,  304,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  288,   -1,   -1,   -1,  316,   -1,
+  318,  295,   -1,   -1,  322,   -1,  300,   -1,   -1,   -1,
+  304,   -1,  330,  331,   -1,   -1,  334,   -1,   -1,  337,
+   -1,  265,  316,  267,  318,   -1,  270,   -1,  322,  418,
+   -1,  275,   -1,   -1,   -1,  279,  330,  331,   -1,   -1,
+  334,   -1,   -1,  337,  288,  265,  418,  267,   -1,   -1,
+  270,  295,   -1,   -1,   -1,  275,  300,   -1,   -1,  279,
+  304,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  288,   -1,
+   -1,   -1,  316,   -1,  318,  295,   -1,   -1,  322,   -1,
+  300,   -1,   -1,   -1,  304,   -1,  330,  331,   -1,   -1,
+  334,   -1,   -1,  337,   -1,   -1,  316,   -1,  318,  265,
+  418,  267,  322,   -1,  270,   -1,   -1,   -1,   -1,  275,
+  330,  331,   -1,  279,  334,   -1,  265,  337,  267,   -1,
+   -1,  270,  288,   -1,  418,   -1,  275,   -1,   -1,  295,
+  279,   -1,   -1,   -1,  300,   -1,   -1,   -1,  304,  288,
+   -1,   -1,   -1,   -1,   -1,   -1,  295,   -1,   -1,   -1,
+  316,  300,  318,   -1,   -1,  304,  322,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  330,  331,   -1,  316,  334,  318,
+  265,  337,  267,  322,  418,  270,   -1,   -1,   -1,   -1,
+  275,  330,  331,   -1,  279,  334,   -1,   -1,  337,   -1,
+   -1,   -1,   -1,  288,   -1,   -1,   -1,   -1,  418,   -1,
+  295,   -1,   -1,   -1,   -1,  300,   -1,   -1,  261,  304,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  272,
+   -1,  316,   -1,  318,  277,   -1,   -1,  322,  281,   -1,
+   -1,  284,   -1,   -1,   -1,  330,  331,   -1,   -1,  334,
+   -1,   -1,  337,  296,  297,   -1,   -1,   -1,  301,  302,
+   -1,   -1,  418,   -1,  307,   -1,  309,  310,  311,  312,
+   -1,   -1,   -1,   -1,  317,   -1,   -1,   -1,  321,  418,
+  323,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+  333,   -1,  335,  336,  261,  338,   -1,   -1,   -1,  342,
+   -1,   -1,   -1,   -1,   -1,  272,   -1,   -1,   -1,   -1,
+  277,   -1,   -1,   -1,  281,   -1,   -1,  284,   -1,  362,
+   -1,   -1,   -1,   -1,   -1,  368,  369,   -1,   -1,  296,
+  297,   -1,   -1,  418,  301,  302,  261,   -1,  263,   -1,
   307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,   -1,
-  317,   -1,   -1,   -1,  321,   -1,   -1,  359,   -1,   -1,
+  317,   -1,   -1,   -1,  321,   -1,  323,   -1,   -1,  284,
    -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,
-   -1,  338,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,  338,  297,   -1,   -1,  342,   -1,  302,   -1,   -1,
+   -1,   -1,  307,   -1,  309,  310,  311,  312,   -1,   -1,
+   -1,   -1,  317,   -1,   -1,  362,  321,   -1,   -1,  261,
+   -1,  368,  369,   -1,   -1,   -1,   -1,   -1,  333,   -1,
+  272,  336,   -1,  338,   -1,  277,   -1,   -1,   -1,  281,
+   -1,   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
+   -1,   -1,   -1,   -1,  296,  297,   -1,  362,   -1,  301,
+  302,   -1,  261,  368,  369,  307,   -1,  309,  310,  311,
+  312,   -1,   -1,  272,   -1,  317,   -1,   -1,  277,  321,
+   -1,  323,  281,   -1,   -1,  284,   -1,   -1,   -1,   -1,
+   -1,  333,   -1,   -1,  336,   -1,  338,  296,  297,   -1,
+  342,   -1,  301,  302,  261,   -1,   -1,   -1,  307,   -1,
+  309,  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,
+  362,   -1,  321,   -1,  323,   -1,  368,  284,   -1,   -1,
+   -1,   -1,   -1,   -1,  333,   -1,   -1,  336,   -1,  338,
+  297,   -1,  261,  342,   -1,  302,   -1,   -1,   -1,   -1,
+  307,   -1,  309,  310,  311,  312,   -1,   -1,   -1,   -1,
+  317,   -1,   -1,  362,  321,  284,   -1,   -1,   -1,  368,
+   -1,   -1,   -1,   -1,   -1,   -1,  333,   -1,  297,  336,
+  261,  338,  263,  302,   -1,   -1,   -1,   -1,  307,   -1,
+  309,  310,  311,  312,   -1,   -1,   -1,   -1,  317,   -1,
+   -1,   -1,  321,  284,   -1,  362,   -1,  364,  365,   -1,
+   -1,  368,   -1,   -1,  333,   -1,  297,  336,  261,  338,
+   -1,  302,   -1,   -1,   -1,   -1,  307,   -1,  309,  310,
+  311,  312,   -1,   -1,   -1,   -1,  317,   -1,   -1,   -1,
+  321,  284,   -1,  362,   -1,  364,  365,   -1,  261,  368,
+  263,   -1,  333,   -1,  297,  336,   -1,  338,   -1,  302,
+   -1,   -1,   -1,   -1,  307,   -1,  309,  310,  311,  312,
+   -1,  284,   -1,   -1,  317,   -1,   -1,   -1,  321,   -1,
+   -1,  362,   -1,   -1,  297,   -1,   -1,  368,  261,  302,
+  333,   -1,   -1,  336,  307,  338,  309,  310,  311,  312,
+   -1,   -1,  315,   -1,  317,   -1,   -1,   -1,  321,   -1,
+   -1,  284,   -1,   -1,   -1,   -1,   -1,   -1,  261,  362,
+  333,  364,  365,  336,  297,  338,   -1,   -1,  301,  302,
+   -1,   -1,   -1,   -1,  307,   -1,  309,  310,  311,  312,
+   -1,  284,   -1,   -1,  317,   -1,   -1,   -1,  321,  362,
+   -1,   -1,   -1,   -1,  297,   -1,   -1,   -1,   -1,  302,
+  333,   -1,   -1,  336,  307,  338,  309,  310,  311,  312,
+   -1,   -1,   -1,   -1,  317,   -1,   -1,   -1,  321,   -1,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  362,
+  333,   -1,   -1,  336,   -1,  338,   -1,   -1,   -1,   -1,
    -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
-   -1,   -1,  359,
+   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  362,
   };
 
-#line 6179 "cs-parser.jay"
+#line 6185 "cs-parser.jay"
 
 // <summary>
 //  A class used to hold info about an operator declarator
@@ -11892,7 +11909,7 @@ void Error_NamedArgumentExpected (NamedArgument a)
 
 void push_current_class (TypeContainer tc, object partial_token)
 {
-	if (module.Evaluator != null){
+	if (module.Evaluator != null && current_container is ModuleContainer){
 		tc.Definition.Modifiers = tc.ModFlags = (tc.ModFlags & ~Modifiers.AccessibilityMask) | Modifiers.PUBLIC;
 		if (undo == null)
 			undo = new Undo ();
@@ -12852,77 +12869,78 @@ namespace yydebug {
   public const int INTO = 356;
   public const int INTERR_NULLABLE = 357;
   public const int EXTERN_ALIAS = 358;
-  public const int ASYNC = 359;
-  public const int REFVALUE = 360;
-  public const int REFTYPE = 361;
-  public const int MAKEREF = 362;
-  public const int GET = 363;
-  public const int SET = 364;
-  public const int LAST_KEYWORD = 365;
-  public const int OPEN_BRACE = 366;
-  public const int CLOSE_BRACE = 367;
-  public const int OPEN_BRACKET = 368;
-  public const int CLOSE_BRACKET = 369;
-  public const int OPEN_PARENS = 370;
-  public const int CLOSE_PARENS = 371;
-  public const int DOT = 372;
-  public const int COMMA = 373;
-  public const int COLON = 374;
-  public const int SEMICOLON = 375;
-  public const int TILDE = 376;
-  public const int PLUS = 377;
-  public const int MINUS = 378;
-  public const int BANG = 379;
-  public const int ASSIGN = 380;
-  public const int OP_LT = 381;
-  public const int OP_GT = 382;
-  public const int BITWISE_AND = 383;
-  public const int BITWISE_OR = 384;
-  public const int STAR = 385;
-  public const int PERCENT = 386;
-  public const int DIV = 387;
-  public const int CARRET = 388;
-  public const int INTERR = 389;
-  public const int DOUBLE_COLON = 390;
-  public const int OP_INC = 391;
-  public const int OP_DEC = 392;
-  public const int OP_SHIFT_LEFT = 393;
-  public const int OP_SHIFT_RIGHT = 394;
-  public const int OP_LE = 395;
-  public const int OP_GE = 396;
-  public const int OP_EQ = 397;
-  public const int OP_NE = 398;
-  public const int OP_AND = 399;
-  public const int OP_OR = 400;
-  public const int OP_MULT_ASSIGN = 401;
-  public const int OP_DIV_ASSIGN = 402;
-  public const int OP_MOD_ASSIGN = 403;
-  public const int OP_ADD_ASSIGN = 404;
-  public const int OP_SUB_ASSIGN = 405;
-  public const int OP_SHIFT_LEFT_ASSIGN = 406;
-  public const int OP_SHIFT_RIGHT_ASSIGN = 407;
-  public const int OP_AND_ASSIGN = 408;
-  public const int OP_XOR_ASSIGN = 409;
-  public const int OP_OR_ASSIGN = 410;
-  public const int OP_PTR = 411;
-  public const int OP_COALESCING = 412;
-  public const int OP_GENERICS_LT = 413;
-  public const int OP_GENERICS_LT_DECL = 414;
-  public const int OP_GENERICS_GT = 415;
-  public const int LITERAL = 416;
-  public const int IDENTIFIER = 417;
-  public const int OPEN_PARENS_LAMBDA = 418;
-  public const int OPEN_PARENS_CAST = 419;
-  public const int GENERIC_DIMENSION = 420;
-  public const int DEFAULT_COLON = 421;
-  public const int OPEN_BRACKET_EXPR = 422;
-  public const int EVAL_STATEMENT_PARSER = 423;
-  public const int EVAL_COMPILATION_UNIT_PARSER = 424;
-  public const int EVAL_USING_DECLARATIONS_UNIT_PARSER = 425;
-  public const int DOC_SEE = 426;
-  public const int GENERATE_COMPLETION = 427;
-  public const int COMPLETE_COMPLETION = 428;
-  public const int UMINUS = 429;
+  public const int REFVALUE = 359;
+  public const int REFTYPE = 360;
+  public const int MAKEREF = 361;
+  public const int ASYNC = 362;
+  public const int AWAIT = 363;
+  public const int GET = 364;
+  public const int SET = 365;
+  public const int LAST_KEYWORD = 366;
+  public const int OPEN_BRACE = 367;
+  public const int CLOSE_BRACE = 368;
+  public const int OPEN_BRACKET = 369;
+  public const int CLOSE_BRACKET = 370;
+  public const int OPEN_PARENS = 371;
+  public const int CLOSE_PARENS = 372;
+  public const int DOT = 373;
+  public const int COMMA = 374;
+  public const int COLON = 375;
+  public const int SEMICOLON = 376;
+  public const int TILDE = 377;
+  public const int PLUS = 378;
+  public const int MINUS = 379;
+  public const int BANG = 380;
+  public const int ASSIGN = 381;
+  public const int OP_LT = 382;
+  public const int OP_GT = 383;
+  public const int BITWISE_AND = 384;
+  public const int BITWISE_OR = 385;
+  public const int STAR = 386;
+  public const int PERCENT = 387;
+  public const int DIV = 388;
+  public const int CARRET = 389;
+  public const int INTERR = 390;
+  public const int DOUBLE_COLON = 391;
+  public const int OP_INC = 392;
+  public const int OP_DEC = 393;
+  public const int OP_SHIFT_LEFT = 394;
+  public const int OP_SHIFT_RIGHT = 395;
+  public const int OP_LE = 396;
+  public const int OP_GE = 397;
+  public const int OP_EQ = 398;
+  public const int OP_NE = 399;
+  public const int OP_AND = 400;
+  public const int OP_OR = 401;
+  public const int OP_MULT_ASSIGN = 402;
+  public const int OP_DIV_ASSIGN = 403;
+  public const int OP_MOD_ASSIGN = 404;
+  public const int OP_ADD_ASSIGN = 405;
+  public const int OP_SUB_ASSIGN = 406;
+  public const int OP_SHIFT_LEFT_ASSIGN = 407;
+  public const int OP_SHIFT_RIGHT_ASSIGN = 408;
+  public const int OP_AND_ASSIGN = 409;
+  public const int OP_XOR_ASSIGN = 410;
+  public const int OP_OR_ASSIGN = 411;
+  public const int OP_PTR = 412;
+  public const int OP_COALESCING = 413;
+  public const int OP_GENERICS_LT = 414;
+  public const int OP_GENERICS_LT_DECL = 415;
+  public const int OP_GENERICS_GT = 416;
+  public const int LITERAL = 417;
+  public const int IDENTIFIER = 418;
+  public const int OPEN_PARENS_LAMBDA = 419;
+  public const int OPEN_PARENS_CAST = 420;
+  public const int GENERIC_DIMENSION = 421;
+  public const int DEFAULT_COLON = 422;
+  public const int OPEN_BRACKET_EXPR = 423;
+  public const int EVAL_STATEMENT_PARSER = 424;
+  public const int EVAL_COMPILATION_UNIT_PARSER = 425;
+  public const int EVAL_USING_DECLARATIONS_UNIT_PARSER = 426;
+  public const int DOC_SEE = 427;
+  public const int GENERATE_COMPLETION = 428;
+  public const int COMPLETE_COMPLETION = 429;
+  public const int UMINUS = 430;
   public const int yyErrorCode = 256;
  }
  namespace yyParser {
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.jay b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.jay
index 4cca86530..320e1e60e 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.jay
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-parser.jay
@@ -252,10 +252,11 @@ namespace Mono.CSharp
 %token INTO
 %token INTERR_NULLABLE
 %token EXTERN_ALIAS
-%token ASYNC
 %token REFVALUE
 %token REFTYPE
 %token MAKEREF
+%token ASYNC
+%token AWAIT
 
 /* C# keywords which are not really keywords */
 %token GET
@@ -664,7 +665,6 @@ attribute_sections
 		else
 			attrs.AddAttributes (sect);
 		$$ = attrs;
-		lbag.AddLocation ($$, savedOpenLocation, savedCloseLocation);
 	  }
 	;
 	
@@ -1733,7 +1733,7 @@ indexer_declaration
 		if (type.Type != null && type.Type.Kind == MemberKind.Void)
 			report.Error (620, GetLocation ($3), "`{0}': indexer return type cannot be `void'", indexer.GetSignatureForError ());  		
 
-		if (indexer.Parameters.IsEmpty) {
+		if (indexer.ParameterInfo.IsEmpty) {
 			report.Error (1551, GetLocation ($5), "Indexers must have at least one parameter");
 		}
 
@@ -3092,6 +3092,7 @@ member_access
 		var lt2 = (Tokenizer.LocatedToken) $2;
 
 		$$ = new QualifiedAliasMember (lt1.Value, lt2.Value, (TypeArguments) $3, lt1.Location);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| primary_expression DOT GENERATE_COMPLETION {
 		$$ = new CompletionMemberAccess ((Expression) $1, null,GetLocation ($3));
@@ -3640,6 +3641,7 @@ unbound_type_name
 		var lt2 = (Tokenizer.LocatedToken) $2;
 
 		$$ = new QualifiedAliasMember (lt1.Value, lt2.Value, (int) $3, lt1.Location);
+		lbag.AddLocation ($$, GetLocation ($2));
 	  }
 	| unbound_type_name DOT IDENTIFIER
 	  {
@@ -3777,6 +3779,7 @@ unary_expression
 		$$ = new Unary (Unary.Operator.OnesComplement, (Expression) $2, GetLocation ($1));
 	  }
 	| cast_expression
+	| await_expression
 	;
 
 cast_expression
@@ -3786,6 +3789,13 @@ cast_expression
 		lbag.AddLocation ($$, GetLocation ($3));
 	  }
 	;
+	
+await_expression
+	: AWAIT unary_expression
+	 {
+		$$ = new Await ((Expression) $2, GetLocation ($1));
+	 }
+	;
 
 	//
 	// The idea to split this out is from Rhys' grammar
@@ -6232,7 +6242,7 @@ void Error_NamedArgumentExpected (NamedArgument a)
 
 void push_current_class (TypeContainer tc, object partial_token)
 {
-	if (module.Evaluator != null){
+	if (module.Evaluator != null && current_container is ModuleContainer){
 		tc.Definition.Modifiers = tc.ModFlags = (tc.ModFlags & ~Modifiers.AccessibilityMask) | Modifiers.PUBLIC;
 		if (undo == null)
 			undo = new Undo ();
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-tokenizer.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-tokenizer.cs
index d7819ee5f..d3d1d485e 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-tokenizer.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/cs-tokenizer.cs
@@ -582,7 +582,6 @@ namespace Mono.CSharp
 			AddKeyword ("while", Token.WHILE);
 			AddKeyword ("partial", Token.PARTIAL);
 			AddKeyword ("where", Token.WHERE);
-			AddKeyword ("async", Token.ASYNC);
 
 			// LINQ keywords
 			AddKeyword ("from", Token.FROM);
@@ -598,6 +597,10 @@ namespace Mono.CSharp
 			AddKeyword ("descending", Token.DESCENDING);
 			AddKeyword ("into", Token.INTO);
 
+			// Contextual async keywords
+			AddKeyword ("async", Token.ASYNC);
+			AddKeyword ("await", Token.AWAIT);
+
 			keywords_preprocessor = new KeywordEntry<PreprocessorDirective>[10][];
 
 			AddPreprocessorKeyword ("region", PreprocessorDirective.Region);
@@ -784,15 +787,24 @@ namespace Mono.CSharp
 				res = -1;
 				break;
 
+			// TODO: async, it's modifiers context only
 			case Token.ASYNC:
 				if (parsing_block > 0 || context.Settings.Version != LanguageVersion.Future) {
 					res = -1;
-					break;
 				}
 				break;
+
+			// TODO: async, it's async block context only
+			case Token.AWAIT:
+				if (context.Settings.Version != LanguageVersion.Future) {
+					res = -1;
+				}
+
+				break;
 			}
 
 			return res;
+			return res;
 		}
 
 		static PreprocessorDirective GetPreprocessorDirective (char[] id, int id_len)
@@ -2667,6 +2679,9 @@ namespace Mono.CSharp
 			int c;
 			int pos = 0;
 			Location start_location = Location;
+			if (quoted)
+				start_location = start_location - 1;
+
 			while (true){
 				c = get_char ();
 				if (c == '"') {
@@ -2737,6 +2752,8 @@ namespace Mono.CSharp
 
 			int pos = 0;
 			int column = col;
+			if (quoted)
+				--column;
 
 			if (c == '\\') {
 				int surrogate;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/decl.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/decl.cs
index 66d5cf432..a00769c49 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/decl.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/decl.cs
@@ -704,9 +704,9 @@ namespace Mono.CSharp {
 			return Parent.NamespaceEntry.LookupNamespaceAlias (name);
 		}
 
-		public virtual FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
+		public virtual FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 		{
-			return Parent.LookupNamespaceOrType (name, arity, loc, ignore_cs0104);
+			return Parent.LookupNamespaceOrType (name, arity, mode, loc);
 		}
 
 		/// <summary>
@@ -865,10 +865,6 @@ namespace Mono.CSharp {
 			get { return null; }
 		}
 
-		public virtual bool HasUnresolvedConstraints {
-			get { return false; }
-		}
-
 		public bool IsObsolete {
 			get {
 				if (GetAttributeObsolete () != null)
@@ -912,6 +908,7 @@ namespace Mono.CSharp {
 			MissingDependency_Undetected = 1 << 4,
 			MissingDependency = 1 << 5,
 			HasDynamicElement = 1 << 6,
+			ConstraintsChecked = 1 << 7,
 
 			IsAccessor = 1 << 9,		// Method is an accessor
 			IsGeneric = 1 << 10,		// Member contains type arguments
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/delegate.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/delegate.cs
index 8809c95a2..8752aebc1 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/delegate.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/delegate.cs
@@ -150,12 +150,10 @@ namespace Mono.CSharp {
 				}
 			}
 
-			ReturnType = ReturnType.ResolveAsType (this);
-			if (ReturnType == null)
+			var ret_type = ReturnType.ResolveAsType (this);
+			if (ret_type == null)
 				return false;
 
-			var ret_type = ReturnType.Type;
-
 			//
 			// We don't have to check any others because they are all
 			// guaranteed to be accessible - they are standard types.
@@ -303,11 +301,14 @@ namespace Mono.CSharp {
 					return_attributes = new ReturnParameter (this, InvokeBuilder.MethodBuilder, Location);
 					Module.PredefinedAttributes.Dynamic.EmitAttribute (return_attributes.Builder, ReturnType.Type, Location);
 				}
+
+				ConstraintChecker.Check (this, ReturnType.Type, ReturnType.Location);
 			}
 
 			Constructor.ParameterInfo.ApplyAttributes (this, Constructor.ConstructorBuilder);
 			Constructor.ConstructorBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
 
+			parameters.CheckConstraints (this);
 			parameters.ApplyAttributes (this, InvokeBuilder.MethodBuilder);
 			InvokeBuilder.MethodBuilder.SetImplementationFlags (MethodImplAttributes.Runtime);
 
@@ -326,7 +327,7 @@ namespace Mono.CSharp {
 			base.Emit ();
 		}
 
-		protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class)
+		protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
 			base_type = Compiler.BuiltinTypes.MulticastDelegate;
 			base_class = null;
@@ -356,7 +357,7 @@ namespace Mono.CSharp {
 
 			parameters.VerifyClsCompliance (this);
 
-			if (!ReturnType.Type.IsCLSCompliant ()) {
+			if (!InvokeBuilder.MemberType.IsCLSCompliant ()) {
 				Report.Warning (3002, 1, Location, "Return type of `{0}' is not CLS-compliant",
 					GetSignatureForError ());
 			}
@@ -404,6 +405,9 @@ namespace Mono.CSharp {
 			if (rc.Module.Compiler.Settings.Version == LanguageVersion.ISO_1)
 				return false;
 
+			if (a.IsGenericParameter && b.IsGenericParameter)
+				return a == b;
+
 			return Convert.ImplicitReferenceConversionExists (a, b);
 		}
 
@@ -458,7 +462,7 @@ namespace Mono.CSharp {
 			MemberAccess ma = new MemberAccess (new MemberAccess (new QualifiedAliasMember ("global", "System", loc), "Delegate", loc), "CreateDelegate", loc);
 
 			Arguments args = new Arguments (3);
-			args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+			args.Add (new Argument (new TypeOf (type, loc)));
 
 			if (method_group.InstanceExpression == null)
 				args.Add (new Argument (new NullLiteral (loc)));
@@ -502,7 +506,7 @@ namespace Mono.CSharp {
 			if (emg != null) {
 				method_group.InstanceExpression = emg.ExtensionExpression;
 				TypeSpec e_type = emg.ExtensionExpression.Type;
-				if (TypeManager.IsValueType (e_type)) {
+				if (TypeSpec.IsValueType (e_type)) {
 					ec.Report.Error (1113, loc, "Extension method `{0}' of value type `{1}' cannot be used to create delegates",
 						delegate_method.GetSignatureForError (), TypeManager.CSharpName (e_type));
 				}
@@ -527,7 +531,7 @@ namespace Mono.CSharp {
 			}
 
 			var expr = method_group.InstanceExpression;
-			if (expr != null && (expr.Type.IsGenericParameter || !TypeManager.IsReferenceType (expr.Type)))
+			if (expr != null && (expr.Type.IsGenericParameter || !TypeSpec.IsReferenceType (expr.Type)))
 				method_group.InstanceExpression = new BoxedCast (expr, ec.BuiltinTypes.Object);
 
 			eclass = ExprClass.Value;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/doc.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/doc.cs
index 46da315aa..ea3b2510c 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/doc.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/doc.cs
@@ -232,12 +232,12 @@ namespace Mono.CSharp
 		FullNamedExpression ResolveMemberName (IMemberContext context, MemberName mn)
 		{
 			if (mn.Left == null)
-				return context.LookupNamespaceOrType (mn.Name, mn.Arity, Location.Null, /*ignore_cs0104=*/ false);
+				return context.LookupNamespaceOrType (mn.Name, mn.Arity, LookupMode.Probing, Location.Null);
 
 			var left = ResolveMemberName (context, mn.Left);
 			var ns = left as Namespace;
 			if (ns != null)
-				return ns.LookupTypeOrNamespace (context, mn.Name, mn.Arity, Location.Null);
+				return ns.LookupTypeOrNamespace (context, mn.Name, mn.Arity, LookupMode.Probing, Location.Null);
 
 			TypeExpr texpr = left as TypeExpr;
 			if (texpr != null) {
@@ -320,7 +320,7 @@ namespace Mono.CSharp
 						if (fne != null) {
 							var ns = fne as Namespace;
 							if (ns != null) {
-								fne = ns.LookupTypeOrNamespace (mc, ParsedName.Name, ParsedName.Arity, Location.Null);
+								fne = ns.LookupTypeOrNamespace (mc, ParsedName.Name, ParsedName.Arity, LookupMode.Probing, Location.Null);
 								if (fne != null) {
 									member = fne.Type;
 								}
@@ -565,6 +565,7 @@ namespace Mono.CSharp
 	{
 		public readonly Parameter.Modifier Modifier;
 		public FullNamedExpression Type;
+		TypeSpec type;
 
 		public DocumentationParameter (Parameter.Modifier modifier, FullNamedExpression type)
 			: this (type)
@@ -579,13 +580,13 @@ namespace Mono.CSharp
 
 		public TypeSpec TypeSpec {
 			get {
-				return Type == null ? null : Type.Type;
+				return type;
 			}
 		}
 
 		public void Resolve (IMemberContext context)
 		{
-			Type = Type.ResolveAsType (context);
+			type = Type.ResolveAsType (context);
 		}
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/driver.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/driver.cs
index e01ad0a78..d0b1cb971 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/driver.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/driver.cs
@@ -82,7 +82,7 @@ namespace Mono.CSharp
 			}
 		}
 
-		void Parse (CompilationSourceFile file, ModuleContainer module)
+		public void Parse (CompilationSourceFile file, ModuleContainer module)
 		{
 			Stream input;
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/dynamic.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/dynamic.cs
index db4ec43e3..c7df9f7c8 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/dynamic.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/dynamic.cs
@@ -47,11 +47,11 @@ namespace Mono.CSharp
 			this.loc = loc;
 		}
 
-		public override TypeExpr ResolveAsType (IMemberContext ec)
+		public override TypeSpec ResolveAsType (IMemberContext ec)
 		{
 			eclass = ExprClass.Type;
 			type = ec.Module.Compiler.BuiltinTypes.Dynamic;
-			return this;
+			return type;
 		}
 	}
 
@@ -383,7 +383,7 @@ namespace Mono.CSharp
 				TypeExpr te = null;
 				Namespace type_ns = module.GlobalRootNamespace.GetNamespace ("System", true);
 				if (type_ns != null) {
-					te = type_ns.LookupType (module, d_name, dyn_args_count + default_args, Location.Null);
+					te = type_ns.LookupType (module, d_name, dyn_args_count + default_args, LookupMode.Normal, loc);
 				}
 
 				if (te != null) {
@@ -459,13 +459,10 @@ namespace Mono.CSharp
 				del_type_instance_access = new TypeExpression (MemberCache.GetMember (dt, d.CurrentType), loc);
 			}
 
-			FullNamedExpression instanceAccessExprType = new GenericTypeExpr (module.PredefinedTypes.CallSiteGeneric.TypeSpec,
+			var instanceAccessExprType = new GenericTypeExpr (module.PredefinedTypes.CallSiteGeneric.TypeSpec,
 				new TypeArguments (del_type_instance_access), loc);
 
-			BlockContext bc = new BlockContext (ec.MemberContext, null, ec.BuiltinTypes.Void);
-
-			instanceAccessExprType = instanceAccessExprType.ResolveAsType (bc);
-			if (instanceAccessExprType == null)
+			if (instanceAccessExprType.ResolveAsType (ec.MemberContext) == null)
 				return;
 
 			bool inflate_using_mvar = context_mvars != null && ec.IsAnonymousStoreyMutateRequired;
@@ -487,6 +484,7 @@ namespace Mono.CSharp
 
 			FieldExpr site_field_expr = new FieldExpr (MemberCache.GetMember (gt, field), loc);
 
+			BlockContext bc = new BlockContext (ec.MemberContext, null, ec.BuiltinTypes.Void);
 			SymbolWriter.OpenCompilerGeneratedBlock (ec);
 
 			Arguments args = new Arguments (1);
@@ -560,7 +558,7 @@ namespace Mono.CSharp
 
 				binder_args.Add (new Argument (new BinderFlags (0, this)));
 				binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, name, loc)));
-				binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+				binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 
 				return new Invocation (GetBinder ("IsEvent", loc), binder_args);
 			}
@@ -621,8 +619,8 @@ namespace Mono.CSharp
 			flags |= ec.HasSet (ResolveContext.Options.CheckedScope) ? CSharpBinderFlags.CheckedContext : 0;
 
 			binder_args.Add (new Argument (new BinderFlags (flags, this)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+			binder_args.Add (new Argument (new TypeOf (type, loc)));
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 			return new Invocation (GetBinder ("Convert", loc), binder_args);
 		}
 	}
@@ -641,7 +639,7 @@ namespace Mono.CSharp
 			Arguments binder_args = new Arguments (3);
 
 			binder_args.Add (new Argument (new BinderFlags (0, this)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 			binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
 
 			return new Invocation (GetBinder ("InvokeConstructor", loc), binder_args);
@@ -674,7 +672,7 @@ namespace Mono.CSharp
 			Arguments binder_args = new Arguments (3);
 
 			binder_args.Add (new Argument (new BinderFlags (flags, this)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 			binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
 
 			isSet |= (flags & CSharpBinderFlags.ValueFromCompoundAssignment) != 0;
@@ -764,7 +762,7 @@ namespace Mono.CSharp
 				if (ta.Resolve (ec)) {
 					var targs = new ArrayInitializer (ta.Count, loc);
 					foreach (TypeSpec t in ta.Arguments)
-						targs.Add (new TypeOf (new TypeExpression (t, loc), loc));
+						targs.Add (new TypeOf (t, loc));
 
 					binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (targs, loc)));
 				}
@@ -772,7 +770,7 @@ namespace Mono.CSharp
 				binder_args.Add (new Argument (new NullLiteral (loc)));
 			}
 
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 
 			Expression real_args;
 			if (args == null) {
@@ -818,7 +816,7 @@ namespace Mono.CSharp
 
 			binder_args.Add (new Argument (new BinderFlags (flags, this)));
 			binder_args.Add (new Argument (new StringLiteral (ec.BuiltinTypes, name, loc)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 			binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
 
 			isSet |= (flags & CSharpBinderFlags.ValueFromCompoundAssignment) != 0;
@@ -939,7 +937,7 @@ namespace Mono.CSharp
 
 			binder_args.Add (new Argument (new BinderFlags (flags, this)));
 			binder_args.Add (new Argument (new MemberAccess (new MemberAccess (sle, "ExpressionType", loc), name, loc)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));
 			binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
 
 			return new Invocation (GetBinder ("UnaryOperation", loc), binder_args);
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/ecore.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/ecore.cs
index 38c4d4b1a..6e736c811 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/ecore.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/ecore.cs
@@ -186,7 +186,7 @@ namespace Mono.CSharp {
 		// This is used if the expression should be resolved as a type or namespace name.
 		// the default implementation fails.   
 		//
-		public virtual TypeExpr ResolveAsType (IMemberContext mc)
+		public virtual TypeSpec ResolveAsType (IMemberContext mc)
 		{
 			ResolveContext ec = new ResolveContext (mc);
 			Expression e = Resolve (ec);
@@ -965,7 +965,7 @@ namespace Mono.CSharp {
 		{
 			Arguments args = new Arguments (2);
 			args.Add (new Argument (child.CreateExpressionTree (ec)));
-			args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+			args.Add (new Argument (new TypeOf (type, loc)));
 
 			if (type.IsPointer || child.Type.IsPointer)
 				Error_PointerInsideExpressionTree (ec);
@@ -1116,7 +1116,7 @@ namespace Mono.CSharp {
 		{
 			Arguments args = Arguments.CreateForExpressionTree (ec, null,
 				child.CreateExpressionTree (ec),
-				new TypeOf (new TypeExpression (type, loc), loc));
+				new TypeOf (type, loc));
 
 			if (type.IsPointer)
 				Error_PointerInsideExpressionTree (ec);
@@ -2065,53 +2065,57 @@ namespace Mono.CSharp {
 			return new SimpleName (Name, targs, loc);
 		}
 
-		protected virtual void Error_TypeOrNamespaceNotFound (IMemberContext ec)
+		protected override Expression DoResolve (ResolveContext ec)
+		{
+			return SimpleNameResolve (ec, null, false);
+		}
+
+		public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
+		{
+			return SimpleNameResolve (ec, right_side, false);
+		}
+
+		protected virtual void Error_TypeOrNamespaceNotFound (IMemberContext ctx)
 		{
-			if (ec.CurrentType != null) {
-				if (ec.CurrentMemberDefinition != null) {
-					MemberCore mc = ec.CurrentMemberDefinition.Parent.GetDefinition (Name);
+			if (ctx.CurrentType != null) {
+				if (ctx.CurrentMemberDefinition != null) {
+					MemberCore mc = ctx.CurrentMemberDefinition.Parent.GetDefinition (Name);
 					if (mc != null) {
-						Error_UnexpectedKind (ec.Module.Compiler.Report, mc, "type", GetMemberType (mc), loc);
+						Error_UnexpectedKind (ctx.Module.Compiler.Report, mc, "type", GetMemberType (mc), loc);
 						return;
 					}
 				}
 			}
 
-			FullNamedExpression retval = ec.LookupNamespaceOrType (Name, -System.Math.Max (1, Arity), loc, true);
+			// MSAF
+			var retval = ctx.LookupNamespaceOrType (Name, Arity, LookupMode.IgnoreAccessibility, loc);
 			if (retval != null) {
-				Error_TypeArgumentsCannotBeUsed (ec, retval.Type, Arity, loc);
-/*
-				var te = retval as TypeExpr;
-				if (HasTypeArguments && te != null && !te.Type.IsGeneric)
-					retval.Error_TypeArgumentsCannotBeUsed (ec.Compiler.Report, loc);
-				else
-					Namespace.Error_InvalidNumberOfTypeArguments (ec.Compiler.Report, retval.Type, loc);
-*/
+				ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (retval.Type);
+				ErrorIsInaccesible (ctx, retval.GetSignatureForError (), loc);
 				return;
 			}
 
-			NamespaceContainer.Error_NamespaceNotFound (loc, Name, ec.Module.Compiler.Report);
-		}
+			retval = ctx.LookupNamespaceOrType (Name, -System.Math.Max (1, Arity), LookupMode.Probing, loc);
+			if (retval != null) {
+				Error_TypeArgumentsCannotBeUsed (ctx, retval.Type, Arity, loc);
+				return;
+			}
 
-		protected override Expression DoResolve (ResolveContext ec)
-		{
-			return SimpleNameResolve (ec, null, false);
-		}
-
-		public override Expression DoResolveLValue (ResolveContext ec, Expression right_side)
-		{
-			return SimpleNameResolve (ec, right_side, false);
+			NamespaceContainer.Error_NamespaceNotFound (loc, Name, ctx.Module.Compiler.Report);
 		}
 
 		public override FullNamedExpression ResolveAsTypeOrNamespace (IMemberContext ec)
 		{
-			FullNamedExpression fne = ec.LookupNamespaceOrType (Name, Arity, loc, /*ignore_cs0104=*/ false);
+			FullNamedExpression fne = ec.LookupNamespaceOrType (Name, Arity, LookupMode.Normal, loc);
 
 			if (fne != null) {
 				if (fne.Type != null && Arity > 0) {
 					if (HasTypeArguments) {
 						GenericTypeExpr ct = new GenericTypeExpr (fne.Type, targs, loc);
-						return ct.ResolveAsType (ec);
+						if (ct.ResolveAsType (ec) == null)
+							return null;
+
+						return ct;
 					}
 
 					return new GenericOpenTypeExpr (fne.Type, loc);
@@ -2131,7 +2135,8 @@ namespace Mono.CSharp {
 						ec.Module.PredefinedAttributes.Dynamic.GetSignatureForError ());
 				}
 
-				return new DynamicTypeExpr (loc).ResolveAsType (ec);
+				fne = new DynamicTypeExpr (loc);
+				fne.ResolveAsType (ec);
 			}
 
 			if (fne != null)
@@ -2143,7 +2148,7 @@ namespace Mono.CSharp {
 
 		public bool IsPossibleTypeOrNamespace (IMemberContext mc)
 		{
-			return mc.LookupNamespaceOrType (Name, Arity, loc, /*ignore_cs0104=*/ false) != null;
+			return mc.LookupNamespaceOrType (Name, Arity, LookupMode.Probing, loc) != null;
 		}
 
 		public override Expression LookupNameExpression (ResolveContext rc, MemberLookupRestrictions restrictions)
@@ -2297,15 +2302,24 @@ namespace Mono.CSharp {
 							} while (ct != null);
 						}
 
-						var retval = rc.LookupNamespaceOrType (Name, -System.Math.Max (1, Arity), loc, true);
-						if (retval != null) {
-							Error_TypeArgumentsCannotBeUsed (rc, retval.Type, Arity, loc);
+						if ((restrictions & MemberLookupRestrictions.InvocableOnly) == 0) {
+							e = rc.LookupNamespaceOrType (Name, Arity, LookupMode.IgnoreAccessibility, loc);
+							if (e != null) {
+								rc.Report.SymbolRelatedToPreviousError (e.Type);
+								ErrorIsInaccesible (rc, e.GetSignatureForError (), loc);
+								return e;
+							}
+						}
+
+						e = rc.LookupNamespaceOrType (Name, -System.Math.Max (1, Arity), LookupMode.Probing, loc);
+						if (e != null) {
+							Error_TypeArgumentsCannotBeUsed (rc, e.Type, Arity, loc);
 						} else {
 							rc.Report.Error (103, loc, "The name `{0}' does not exist in the current context", Name);
 						}
 					}
 
-					return null;
+					return ErrorExpression.Instance;
 				}
 
 				if (rc.Module.Evaluator != null) {
@@ -2372,7 +2386,7 @@ namespace Mono.CSharp {
 		// value will be returned if the expression is not a type
 		// reference
 		//
-		public override TypeExpr ResolveAsType (IMemberContext mc)
+		public override TypeSpec ResolveAsType (IMemberContext mc)
 		{
 			FullNamedExpression fne = ResolveAsTypeOrNamespace (mc);
 
@@ -2385,30 +2399,27 @@ namespace Mono.CSharp {
 				return null;
 			}
 
-			if (!te.type.IsAccessible (mc)) {
-				mc.Module.Compiler.Report.SymbolRelatedToPreviousError (te.Type);
-				ErrorIsInaccesible (mc, te.Type.GetSignatureForError (), loc);
-			}
-
 			te.loc = loc;
 
-			var dep = te.type.GetMissingDependencies ();
+			type = te.Type;
+
+			var dep = type.GetMissingDependencies ();
 			if (dep != null) {
 				ImportedTypeDefinition.Error_MissingDependency (mc, dep, loc);
 			}
 
 			//
 			// Obsolete checks cannot be done when resolving base context as they
-			// require type dependecies to be set but we are just resolving them
+			// require type dependencies to be set but we are in process of resolving them
 			//
 			if (!(mc is TypeContainer.BaseContext)) {
-				ObsoleteAttribute obsolete_attr = te.Type.GetAttributeObsolete ();
+				ObsoleteAttribute obsolete_attr = type.GetAttributeObsolete ();
 				if (obsolete_attr != null && !mc.IsObsolete) {
 					AttributeTester.Report_ObsoleteMessage (obsolete_attr, te.GetSignatureForError (), Location, mc.Module.Compiler.Report);
 				}
 			}
 
-			return te;
+			return type;
 		}
 
 
@@ -2426,12 +2437,14 @@ namespace Mono.CSharp {
 	{
 		public sealed override FullNamedExpression ResolveAsTypeOrNamespace (IMemberContext mc)
 		{
-			return ResolveAsType (mc);
+			ResolveAsType (mc);
+			return this;
 		}
 
 		protected sealed override Expression DoResolve (ResolveContext ec)
 		{
-			return ResolveAsType (ec);
+			ResolveAsType (ec);
+			return this;
 		}
 
 		public override bool Equals (object obj)
@@ -2461,9 +2474,9 @@ namespace Mono.CSharp {
 			loc = l;
 		}
 
-		public sealed override TypeExpr ResolveAsType (IMemberContext ec)
+		public sealed override TypeSpec ResolveAsType (IMemberContext ec)
 		{
-			return this;
+			return type;
 		}
 
 		public override object Accept (StructuralVisitor visitor)
@@ -2532,7 +2545,7 @@ namespace Mono.CSharp {
 			// Overload resulution works on virtual or non-virtual members only (no overrides). That
 			// means for base.member access we have to find the closest match after we found best candidate
 			//
-			if ((method.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.STATIC)) != Modifiers.STATIC) {
+			if ((method.Modifiers & (Modifiers.ABSTRACT | Modifiers.VIRTUAL | Modifiers.OVERRIDE)) != 0) {
 				//
 				// The method could already be what we are looking for
 				//
@@ -2667,9 +2680,7 @@ namespace Mono.CSharp {
 			// a constant, field, property, local variable, or parameter with the same type as the meaning of E as a type-name
 
 			if (left is MemberExpr || left is VariableReference) {
-				rc.Report.DisableReporting ();
-				Expression identical_type = rc.LookupNamespaceOrType (name.Name, 0, loc, true) as TypeExpr;
-				rc.Report.EnableReporting ();
+				var identical_type = rc.LookupNamespaceOrType (name.Name, 0, LookupMode.Probing, loc) as TypeExpr;
 				if (identical_type != null && identical_type.Type == left.Type)
 					return identical_type;
 			}
@@ -2779,7 +2790,7 @@ namespace Mono.CSharp {
 
 		public virtual MemberExpr ResolveMemberAccess (ResolveContext ec, Expression left, SimpleName original)
 		{
-			if (left != null && left.IsNull && TypeManager.IsReferenceType (left.Type)) {
+			if (left != null && left.IsNull && TypeSpec.IsReferenceType (left.Type)) {
 				ec.Report.Warning (1720, 1, left.Location,
 					"Expression will always cause a `{0}'", "System.NullReferenceException");
 			}
@@ -2791,9 +2802,9 @@ namespace Mono.CSharp {
 		protected void EmitInstance (EmitContext ec, bool prepare_for_load)
 		{
 			TypeSpec instance_type = InstanceExpression.Type;
-			if (TypeManager.IsValueType (instance_type)) {
+			if (TypeSpec.IsValueType (instance_type)) {
 				if (InstanceExpression is IMemoryLocation) {
-					((IMemoryLocation) InstanceExpression).AddressOf (ec, AddressOp.LoadStore);
+					((IMemoryLocation) InstanceExpression).AddressOf (ec, AddressOp.Load);
 				} else {
 					LocalTemporary t = new LocalTemporary (instance_type);
 					InstanceExpression.Emit (ec);
@@ -2804,7 +2815,7 @@ namespace Mono.CSharp {
 				InstanceExpression.Emit (ec);
 
 				// Only to make verifier happy
-				if (instance_type.IsGenericParameter && !(InstanceExpression is This) && TypeManager.IsReferenceType (instance_type))
+				if (instance_type.IsGenericParameter && !(InstanceExpression is This) && TypeSpec.IsReferenceType (instance_type))
 					ec.Emit (OpCodes.Box, instance_type);
 			}
 
@@ -3388,7 +3399,7 @@ namespace Mono.CSharp {
 				//
 				// With identical parameter lists
 				//
-				if (!TypeSpecComparer.Equals (p_m.Parameters.Types,q_m.Parameters.Types))
+				if (!TypeSpecComparer.Equals (p_m.Parameters.Types, q_m.Parameters.Types))
 					return 0;
 
 				p = p_m.ReturnType;
@@ -4034,7 +4045,7 @@ namespace Mono.CSharp {
 				//
 				// Deploy custom error reporting for lambda methods. When probing lambda methods
 				// keep all errors reported in separate set and once we are done and no best
-				// candidate found, this set is used to report more details about what was wrong
+				// candidate was found, this set is used to report more details about what was wrong
 				// with lambda body
 				//
 				if (argument.Expr.Type == InternalType.AnonymousMethod) {
@@ -4044,6 +4055,10 @@ namespace Mono.CSharp {
 					}
 				}
 
+				//
+				// Use implicit conversion in all modes to return same candidates when the expression
+				// is used as argument or delegate conversion
+				//
 				if (!Convert.ImplicitConversionExists (ec, argument.Expr, parameter)) {
 					if (lambda_conv_msgs != null) {
 						lambda_conv_msgs.EndSession ();
@@ -4408,7 +4423,7 @@ namespace Mono.CSharp {
 				else
 					ec.Report.Error (1620, loc, "Argument `#{0}' is missing `{1}' modifier",
 						index, Parameter.GetModifierSignature (mod));
-			} else {
+			} else if (a.Expr != ErrorExpression.Instance) {
 				string p1 = a.GetSignatureForError ();
 				string p2 = TypeManager.CSharpName (paramType);
 
@@ -4798,7 +4813,7 @@ namespace Mono.CSharp {
 		public bool IsMarshalByRefAccess (ResolveContext rc)
 		{
 			// Checks possible ldflda of field access expression
-			return !spec.IsStatic && TypeManager.IsValueType (spec.MemberType) && !(InstanceExpression is This) &&
+			return !spec.IsStatic && TypeSpec.IsValueType (spec.MemberType) && !(InstanceExpression is This) &&
 				rc.Module.PredefinedTypes.MarshalByRefObject.Define () &&
 				TypeSpec.IsBaseClass (spec.DeclaringType, rc.Module.PredefinedTypes.MarshalByRefObject.TypeSpec, false);
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/enum.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/enum.cs
index 8c092d66e..ec23b5267 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/enum.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/enum.cs
@@ -27,11 +27,11 @@ namespace Mono.CSharp {
 	{
 		class EnumTypeExpr : TypeExpr
 		{
-			public override TypeExpr ResolveAsType (IMemberContext ec)
+			public override TypeSpec ResolveAsType (IMemberContext ec)
 			{
 				type = ec.CurrentType;
 				eclass = ExprClass.Type;
-				return this;
+				return type;
 			}
 		}
 
@@ -156,11 +156,13 @@ namespace Mono.CSharp {
 			Modifiers.INTERNAL |
 			Modifiers.PRIVATE;
 
+		readonly TypeExpr underlying_type_expr;
+
 		public Enum (NamespaceContainer ns, DeclSpace parent, TypeExpression type,
 			     Modifiers mod_flags, MemberName name, Attributes attrs)
 			: base (ns, parent, name, attrs, MemberKind.Enum)
 		{
-			base_type_expr = type;
+			underlying_type_expr = type;
 			var accmods = IsTopLevel ? Modifiers.INTERNAL : Modifiers.PRIVATE;
 			ModFlags = ModifiersExtensions.Check (AllowedModifiers, mod_flags, accmods, Location, Report);
 			spec = new EnumSpec (null, this, null, null, ModFlags);
@@ -176,7 +178,7 @@ namespace Mono.CSharp {
 
 		public TypeExpr BaseTypeExpression {
 			get {
-				return base_type_expr;
+				return underlying_type_expr;
 			}
 		}
 
@@ -219,7 +221,7 @@ namespace Mono.CSharp {
 
 		protected override bool DefineNestedTypes ()
 		{
-			((EnumSpec) spec).UnderlyingType = base_type_expr == null ? Compiler.BuiltinTypes.Int : base_type_expr.Type;
+			((EnumSpec) spec).UnderlyingType = underlying_type_expr == null ? Compiler.BuiltinTypes.Int : underlying_type_expr.Type;
 
 			TypeBuilder.DefineField (UnderlyingValueField, UnderlyingType.GetMetaInfo (),
 				FieldAttributes.Public | FieldAttributes.SpecialName | FieldAttributes.RTSpecialName);
@@ -248,10 +250,10 @@ namespace Mono.CSharp {
 			return true;
 		}
 
-		protected override TypeExpr[] ResolveBaseTypes (out TypeExpr base_class)
+		protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
 			base_type = Compiler.BuiltinTypes.Enum;
-			base_class = base_type_expr;
+			base_class = null;
 			return null;
 		}
 		
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/eval.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/eval.cs
index dcfd1cb6f..3bbae9555 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/eval.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/eval.cs
@@ -62,6 +62,7 @@ namespace Mono.CSharp
 
 		Type base_class;
 		bool inited;
+		int startup_files;
 
 		readonly CompilerContext ctx;
 		readonly ModuleContainer module;
@@ -78,6 +79,7 @@ namespace Mono.CSharp
 			source_file = new CompilationSourceFile ("{interactive}", "", 1);
  			source_file.NamespaceContainer = new NamespaceContainer (null, module, null, source_file);
 
+			startup_files = ctx.SourceFiles.Count;
 			ctx.SourceFiles.Add (source_file);
 
 			// FIXME: Importer needs this assembly for internalsvisibleto
@@ -106,6 +108,18 @@ namespace Mono.CSharp
 			inited = true;
 		}
 
+		void ParseStartupFiles ()
+		{
+			Driver d = new Driver (ctx);
+
+			Location.Initialize (ctx.SourceFiles);
+
+			for (int i = 0; i < startup_files; ++i) {
+				var sf = ctx.Settings.SourceFiles [i];
+				d.Parse (sf, module);
+			}
+		}
+
 		void Reset ()
 		{
 			CompilerCallableEntryPoint.PartialReset ();
@@ -195,10 +209,12 @@ namespace Mono.CSharp
 			}
 
 			lock (evaluator_lock){
-				if (!inited)
+				if (!inited) {
 					Init ();
-				else
+					ParseStartupFiles ();
+				} else {
 					ctx.Report.Printer.Reset ();
+				}
 
 				bool partial_input;
 				CSharpParser parser = ParseString (ParseMode.Silent, input, out partial_input);
@@ -744,7 +760,7 @@ namespace Mono.CSharp
 			var res = new List<string> ();
 
 			foreach (var ue in source_file.NamespaceContainer.Usings)
-				res.Add (ue.ToString ());
+				res.Add (ue.Name);
 			return res;
 		}
 		
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/expression.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/expression.cs
index 087068c73..adce86b0a 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/expression.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/expression.cs
@@ -730,6 +730,9 @@ namespace Mono.CSharp
 				if (oper_expr == null)
 					continue;
 
+				if (oper_expr == ErrorExpression.Instance)
+					return oper_expr;
+
 				//
 				// decimal type is predefined but has user-operators
 				//
@@ -748,8 +751,13 @@ namespace Mono.CSharp
 
 				int result = OverloadResolver.BetterTypeConversion (ec, best_expr.Type, t);
 				if (result == 0) {
-					ec.Report.Error (35, loc, "Operator `{0}' is ambiguous on an operand of type `{1}'",
-						OperName (Oper), TypeManager.CSharpName (expr.Type));
+					if ((oper_expr is UserOperatorCall || oper_expr is UserCast) && (best_expr is UserOperatorCall || best_expr is UserCast)) {
+						ec.Report.Error (35, loc, "Operator `{0}' is ambiguous on an operand of type `{1}'",
+							OperName (Oper), expr.Type.GetSignatureForError ());
+					} else {
+						Error_OperatorCannotBeApplied (ec, loc, OperName (Oper), expr.Type);
+					}
+
 					break;
 				}
 
@@ -1280,7 +1288,7 @@ namespace Mono.CSharp
 	public abstract class Probe : Expression {
 		public Expression ProbeType;
 		protected Expression expr;
-		protected TypeExpr probe_type_expr;
+		protected TypeSpec probe_type_expr;
 		
 		public Probe (Expression expr, Expression probe_type, Location l)
 		{
@@ -1305,12 +1313,12 @@ namespace Mono.CSharp
 			if (expr == null)
 				return null;
 
-			if (probe_type_expr.Type.IsStatic) {
+			if (probe_type_expr.IsStatic) {
 				ec.Report.Error (-244, loc, "The `{0}' operator cannot be applied to an operand of a static type",
 					OperatorName);
 			}
 			
-			if (expr.Type.IsPointer || probe_type_expr.Type.IsPointer) {
+			if (expr.Type.IsPointer || probe_type_expr.IsPointer) {
 				ec.Report.Error (244, loc, "The `{0}' operator cannot be applied to an operand of pointer type",
 					OperatorName);
 				return null;
@@ -1365,7 +1373,12 @@ namespace Mono.CSharp
 			}
 
 			expr.Emit (ec);
-			ec.Emit (OpCodes.Isinst, probe_type_expr.Type);
+
+			// Only to make verifier happy
+			if (probe_type_expr.IsGenericParameter && TypeSpec.IsValueType (expr.Type))
+				ec.Emit (OpCodes.Box, expr.Type);
+
+			ec.Emit (OpCodes.Isinst, probe_type_expr);
 			ec.Emit (OpCodes.Ldnull);
 			ec.Emit (OpCodes.Cgt_Un);
 		}
@@ -1376,7 +1389,7 @@ namespace Mono.CSharp
 				expr_unwrap.EmitCheck (ec);
 			} else {
 				expr.Emit (ec);
-				ec.Emit (OpCodes.Isinst, probe_type_expr.Type);
+				ec.Emit (OpCodes.Isinst, probe_type_expr);
 			}			
 			ec.Emit (on_true ? OpCodes.Brtrue : OpCodes.Brfalse, target);
 		}
@@ -1385,10 +1398,10 @@ namespace Mono.CSharp
 		{
 			if (result)
 				ec.Report.Warning (183, 1, loc, "The given expression is always of the provided (`{0}') type",
-					TypeManager.CSharpName (probe_type_expr.Type));
+					TypeManager.CSharpName (probe_type_expr));
 			else
 				ec.Report.Warning (184, 1, loc, "The given expression is never of the provided (`{0}') type",
-					TypeManager.CSharpName (probe_type_expr.Type));
+					TypeManager.CSharpName (probe_type_expr));
 
 			return ReducedExpression.Create (new BoolConstant (ec.BuiltinTypes, result, loc), this);
 		}
@@ -1418,7 +1431,7 @@ namespace Mono.CSharp
 
 			type = ec.BuiltinTypes.Bool;
 			eclass = ExprClass.Value;
-			TypeSpec t = probe_type_expr.Type;
+			TypeSpec t = probe_type_expr;
 			bool t_is_nullable = false;
 			if (t.IsNullableType) {
 				var ut = Nullable.NullableInfo.GetUnderlyingType (t);
@@ -1463,15 +1476,21 @@ namespace Mono.CSharp
 						OperatorName, t.GetSignatureForError ());
 				}
 
-				if (d.IsStruct) {
-					if (Convert.ImplicitBoxingConversion (null, d, t) != null)
+				if (TypeManager.IsGenericParameter (d))
+					return ResolveGenericParameter (ec, t, (TypeParameterSpec) d);
+
+				if (TypeSpec.IsValueType (d)) {
+					if (Convert.ImplicitBoxingConversion (null, d, t) != null) {
+						if (d_is_nullable && !t_is_nullable) {
+							expr_unwrap = Nullable.Unwrap.Create (expr, false);
+							return this;
+						}
+
 						return CreateConstantResult (ec, true);
+					}
 				} else {
-					if (TypeManager.IsGenericParameter (d))
-						return ResolveGenericParameter (ec, t, (TypeParameterSpec) d);
-
-					if (InflatedTypeSpec.ContainsTypeParameter (d))
-						return this;
+				//	if (InflatedTypeSpec.ContainsTypeParameter (d))
+				//		return this;
 
 					if (Convert.ImplicitReferenceConversionExists (d, t) ||
 						Convert.ExplicitReferenceConversionExists (d, t)) {
@@ -1491,7 +1510,7 @@ namespace Mono.CSharp
 			}
 
 			if (TypeManager.IsGenericParameter (expr.Type)) {
-				if (t.IsValueType && expr.Type == d)
+				if (expr.Type == d && TypeSpec.IsValueType (t))
 					return CreateConstantResult (ec, true);
 
 				expr = new BoxedCast (expr, d);
@@ -1549,11 +1568,11 @@ namespace Mono.CSharp
 					return null;
 			}
 
-			type = probe_type_expr.Type;
+			type = probe_type_expr;
 			eclass = ExprClass.Value;
 			TypeSpec etype = expr.Type;
 
-			if (!TypeManager.IsReferenceType (type) && !type.IsNullableType) {
+			if (!TypeSpec.IsReferenceType (type) && !type.IsNullableType) {
 				if (TypeManager.IsGenericParameter (type)) {
 					ec.Report.Error (413, loc,
 						"The `as' operator cannot be used with a non-reference type parameter `{0}'. Consider adding `class' or a reference type constraint",
@@ -1632,12 +1651,10 @@ namespace Mono.CSharp
 			if (expr == null)
 				return null;
 
-			TypeExpr target = target_type.ResolveAsType (ec);
-			if (target == null)
+			type = target_type.ResolveAsType (ec);
+			if (type == null)
 				return null;
 
-			type = target.Type;
-
 			if (type.IsStatic) {
 				ec.Report.Error (716, loc, "Cannot convert to static type `{0}'", TypeManager.CSharpName (type));
 				return null;
@@ -1728,18 +1745,16 @@ namespace Mono.CSharp
 		{
 			Arguments args = new Arguments (2);
 			args.Add (new Argument (this));
-			args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+			args.Add (new Argument (new TypeOf (type, loc)));
 			return CreateExpressionFactoryCall (ec, "Constant", args);
 		}
 
 		protected override Expression DoResolve (ResolveContext ec)
 		{
-			TypeExpr texpr = expr.ResolveAsType (ec);
-			if (texpr == null)
+			type = expr.ResolveAsType (ec);
+			if (type == null)
 				return null;
 
-			type = texpr.Type;
-
 			if (type.IsStatic) {
 				ec.Report.Error (-244, loc, "The `default value' operator cannot be applied to an operand of a static type");
 			}
@@ -1747,7 +1762,7 @@ namespace Mono.CSharp
 			if (type.IsPointer)
 				return new NullLiteral (Location).ConvertImplicitly (type);
 
-			if (TypeManager.IsReferenceType (type))
+			if (TypeSpec.IsReferenceType (type))
 				return new NullConstant (type, loc);
 
 			Constant c = New.Constantify (type, expr.Location);
@@ -2260,6 +2275,9 @@ namespace Mono.CSharp
 
 		public static void Error_OperatorCannotBeApplied (ResolveContext ec, Expression left, Expression right, string oper, Location loc)
 		{
+			if (left.Type == InternalType.FakeInternalType || right.Type == InternalType.FakeInternalType)
+				return;
+
 			string l, r;
 			l = TypeManager.CSharpName (left.Type);
 			r = TypeManager.CSharpName (right.Type);
@@ -2955,10 +2973,10 @@ namespace Mono.CSharp
 			}
 
 			if (ec.Module.Compiler.Settings.Version >= LanguageVersion.ISO_2 &&
-				((left.Type.IsNullableType && (right is NullLiteral || right.Type.IsNullableType || TypeManager.IsValueType (right.Type))) ||
-				(TypeManager.IsValueType (left.Type) && right is NullLiteral) ||
-				(right.Type.IsNullableType && (left is NullLiteral || left.Type.IsNullableType || TypeManager.IsValueType (left.Type))) ||
-				(TypeManager.IsValueType (right.Type) && left is NullLiteral))) {
+				((left.Type.IsNullableType && (right is NullLiteral || right.Type.IsNullableType || TypeSpec.IsValueType (right.Type))) ||
+				(TypeSpec.IsValueType (left.Type) && right is NullLiteral) ||
+				(right.Type.IsNullableType && (left is NullLiteral || left.Type.IsNullableType || TypeSpec.IsValueType (left.Type))) ||
+				(TypeSpec.IsValueType (right.Type) && left is NullLiteral))) {
 				var lifted = new Nullable.LiftedBinaryOperator (oper, left, right, loc);
 				lifted.state = state;
 				return lifted.Resolve (ec);
@@ -3300,7 +3318,7 @@ namespace Mono.CSharp
 				l = tparam_l.GetEffectiveBase ();
 				left = new BoxedCast (left, l);
 			} else if (left is NullLiteral && tparam_r == null) {
-				if (!TypeManager.IsReferenceType (r) || r.Kind == MemberKind.InternalCompilerType)
+				if (!TypeSpec.IsReferenceType (r) || r.Kind == MemberKind.InternalCompilerType)
 					return null;
 
 				return this;
@@ -3318,7 +3336,7 @@ namespace Mono.CSharp
 				r = tparam_r.GetEffectiveBase ();
 				right = new BoxedCast (right, r);
 			} else if (right is NullLiteral) {
-				if (!TypeManager.IsReferenceType (l) || l.Kind == MemberKind.InternalCompilerType)
+				if (!TypeSpec.IsReferenceType (l) || l.Kind == MemberKind.InternalCompilerType)
 					return null;
 
 				return this;
@@ -3384,7 +3402,7 @@ namespace Mono.CSharp
 				return null;
 
 			// Reject allowed explicit conversions like int->object
-			if (!TypeManager.IsReferenceType (l) || !TypeManager.IsReferenceType (r))
+			if (!TypeSpec.IsReferenceType (l) || !TypeSpec.IsReferenceType (r))
 				return null;
 
 			if (l.BuiltinType == BuiltinTypeSpec.Type.String || l.BuiltinType == BuiltinTypeSpec.Type.Delegate || MemberCache.GetUserOperator (l, CSharp.Operator.OpType.Equality, false) != null)
@@ -3875,7 +3893,7 @@ namespace Mono.CSharp
 
 			binder_args.Add (new Argument (new EnumConstant (new IntLiteral (ec.BuiltinTypes, (int) flags, loc), ec.Module.PredefinedTypes.BinderFlags.Resolve ())));
 			binder_args.Add (new Argument (new MemberAccess (new MemberAccess (sle, "ExpressionType", loc), GetOperatorExpressionTypeName (), loc)));
-			binder_args.Add (new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc)));									
+			binder_args.Add (new Argument (new TypeOf (ec.CurrentType, loc)));									
 			binder_args.Add (new Argument (new ImplicitlyTypedArrayCreation (args.CreateDynamicBinderArguments (ec), loc)));
 
 			return new Invocation (new MemberAccess (new TypeExpression (ec.Module.PredefinedTypes.Binder.TypeSpec, loc), "BinaryOperation", loc), binder_args);
@@ -4769,8 +4787,13 @@ namespace Mono.CSharp
 			// flag it for capturing
 			//
 			if (ec.MustCaptureVariable (local_info)) {
-				if (local_info.AddressTaken)
+				if (local_info.AddressTaken) {
 					AnonymousMethodExpression.Error_AddressOfCapturedVar (ec, this, loc);
+				} else if (local_info.IsFixed) {
+					ec.Report.Error (1764, loc,
+						"Cannot use fixed local `{0}' inside an anonymous method, lambda expression or query expression",
+						GetSignatureForError ());
+				}
 
 				if (ec.IsVariableCapturingRequired) {
 					AnonymousMethodStorey storey = local_info.Block.Explicit.CreateAnonymousMethodStorey (ec);
@@ -5241,18 +5264,18 @@ namespace Mono.CSharp
 				if (ma != null) {
 					var left_type = ma.LeftExpression as TypeExpr;
 					if (left_type != null) {
-						args.Insert (0, new Argument (new TypeOf (left_type, loc).Resolve (ec), Argument.AType.DynamicTypeName));
+						args.Insert (0, new Argument (new TypeOf (left_type.Type, loc).Resolve (ec), Argument.AType.DynamicTypeName));
 					} else {
 						//
 						// Any value type has to be pass as by-ref to get back the same
 						// instance on which the member was called
 						//
-						var mod = TypeManager.IsValueType (ma.LeftExpression.Type) ? Argument.AType.Ref : Argument.AType.None;
+						var mod = TypeSpec.IsValueType (ma.LeftExpression.Type) ? Argument.AType.Ref : Argument.AType.None;
 						args.Insert (0, new Argument (ma.LeftExpression.Resolve (ec), mod));
 					}
 				} else {	// is SimpleName
 					if (ec.IsStatic) {
-						args.Insert (0, new Argument (new TypeOf (new TypeExpression (ec.CurrentType, loc), loc).Resolve (ec), Argument.AType.DynamicTypeName));
+						args.Insert (0, new Argument (new TypeOf (ec.CurrentType, loc).Resolve (ec), Argument.AType.DynamicTypeName));
 					} else {
 						args.Insert (0, new Argument (new This (loc).Resolve (ec)));
 					}
@@ -5410,7 +5433,7 @@ namespace Mono.CSharp
 						// it.
 						var iml = instance_expr as IMemoryLocation;
 						if (iml != null) {
-							iml.AddressOf (ec, AddressOp.LoadStore);
+							iml.AddressOf (ec, AddressOp.Load);
 						} else {
 							LocalTemporary temp = new LocalTemporary (iexpr_type);
 							instance_expr.Emit (ec);
@@ -5626,7 +5649,7 @@ namespace Mono.CSharp
 			Arguments args;
 			if (method == null) {
 				args = new Arguments (1);
-				args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+				args.Add (new Argument (new TypeOf (type, loc)));
 			} else {
 				args = Arguments.CreateForExpressionTree (ec,
 					arguments, new TypeOfMethod (method, loc));
@@ -5637,11 +5660,10 @@ namespace Mono.CSharp
 		
 		protected override Expression DoResolve (ResolveContext ec)
 		{
-			TypeExpr texpr = RequestedType.ResolveAsType (ec);
-			if (texpr == null)
+			type = RequestedType.ResolveAsType (ec);
+			if (type == null)
 				return null;
 
-			type = texpr.Type;
 			eclass = ExprClass.Value;
 
 			if (type.IsPointer) {
@@ -5715,7 +5737,7 @@ namespace Mono.CSharp
 			method = ConstructorLookup (ec, type, ref arguments, loc);
 
 			if (dynamic) {
-				arguments.Insert (0, new Argument (new TypeOf (texpr, loc).Resolve (ec), Argument.AType.DynamicTypeName));
+				arguments.Insert (0, new Argument (new TypeOf (type, loc).Resolve (ec), Argument.AType.DynamicTypeName));
 				return new DynamicConstructorBinder (type, arguments, loc).Resolve (ec);
 			}
 
@@ -5792,7 +5814,7 @@ namespace Mono.CSharp
 		//
 		public virtual bool Emit (EmitContext ec, IMemoryLocation target)
 		{
-			bool is_value_type = TypeManager.IsValueType (type);
+			bool is_value_type = TypeSpec.IsValueType (type);
 			VariableReference vr = target as VariableReference;
 
 			if (target != null && is_value_type && (vr != null || method == null)) {
@@ -5826,7 +5848,7 @@ namespace Mono.CSharp
 		public override void Emit (EmitContext ec)
 		{
 			LocalTemporary v = null;
-			if (method == null && TypeManager.IsValueType (type)) {
+			if (method == null && TypeSpec.IsValueType (type)) {
 				// TODO: Use temporary variable from pool
 				v = new LocalTemporary (type);
 			}
@@ -5838,7 +5860,7 @@ namespace Mono.CSharp
 		public override void EmitStatement (EmitContext ec)
 		{
 			LocalTemporary v = null;
-			if (method == null && TypeManager.IsValueType (type)) {
+			if (method == null && TypeSpec.IsValueType (type)) {
 				// TODO: Use temporary variable from pool
 				v = new LocalTemporary (type);
 			}
@@ -6198,7 +6220,7 @@ namespace Mono.CSharp
 
 			if (array_data == null) {
 				args = new Arguments (arguments.Count + 1);
-				args.Add (new Argument (new TypeOf (new TypeExpression (array_element_type, loc), loc)));
+				args.Add (new Argument (new TypeOf (array_element_type, loc)));
 				foreach (Expression a in arguments)
 					args.Add (new Argument (a.CreateExpressionTree (ec)));
 
@@ -6211,7 +6233,7 @@ namespace Mono.CSharp
 			}
 
 			args = new Arguments (array_data == null ? 1 : array_data.Count + 1);
-			args.Add (new Argument (new TypeOf (new TypeExpression (array_element_type, loc), loc)));
+			args.Add (new Argument (new TypeOf (array_element_type, loc)));
 			if (array_data != null) {
 				for (int i = 0; i < array_data.Count; ++i) {
 					Expression e = array_data [i];
@@ -6232,6 +6254,8 @@ namespace Mono.CSharp
 
 				if (probe.Count > 0 && probe [0] is ArrayInitializer) {
 					probe = (ArrayInitializer) probe[0];
+				} else if (dimensions > i) {
+					continue;
 				} else {
 					return;
 				}
@@ -6295,11 +6319,10 @@ namespace Mono.CSharp
 				array_type_expr = requested_base_type;
 			}
 
-			array_type_expr = array_type_expr.ResolveAsType (ec);
+			type = array_type_expr.ResolveAsType (ec);
 			if (array_type_expr == null)
 				return false;
 
-			type = array_type_expr.Type;
 			var ac = type as ArrayContainer;
 			if (ac == null) {
 				ec.Report.Error (622, loc, "Can only use array initializer expressions to assign to array types. Try using a new expression instead");
@@ -7117,7 +7140,11 @@ namespace Mono.CSharp
 	{
 		FullNamedExpression texpr;
 		
-		public FullNamedExpression FullNamedExpression { get { return texpr; }}
+		public FullNamedExpression FullNamedExpression {
+			get {
+				return texpr;
+			}
+		}
 		
 		public RefValueExpr (Expression expr, FullNamedExpression texpr, Location loc)
 			: base (expr)
@@ -7129,11 +7156,10 @@ namespace Mono.CSharp
 		protected override Expression DoResolve (ResolveContext rc)
 		{
 			expr = expr.Resolve (rc);
-			texpr = texpr.ResolveAsType (rc);
-			if (expr == null || texpr == null)
+			type = texpr.ResolveAsType (rc);
+			if (expr == null || type == null)
 				return null;
 
-			type = texpr.Type;
 			expr = Convert.ImplicitConversionRequired (rc, expr, rc.Module.PredefinedTypes.TypedReference.Resolve (), loc);
 			eclass = ExprClass.Value;
 			return this;
@@ -7231,6 +7257,15 @@ namespace Mono.CSharp
 			loc = l;
 		}
 
+		//
+		// Use this constructor for any compiler generated typeof expression
+		//
+		public TypeOf (TypeSpec type, Location loc)
+		{
+			this.typearg = type;
+			this.loc = loc;
+		}
+
 		#region Properties
 		public TypeSpec TypeArgument {
 			get {
@@ -7256,29 +7291,29 @@ namespace Mono.CSharp
 
 		protected override Expression DoResolve (ResolveContext ec)
 		{
-			TypeExpr texpr;
-
-			//
-			// Pointer types are allowed without explicit unsafe, they are just tokens
-			//
-			using (ec.Set (ResolveContext.Options.UnsafeScope)) {
-				texpr = QueriedType.ResolveAsType (ec);
-			}
+			if (eclass != ExprClass.Unresolved)
+				return this;
 
-			if (texpr == null)
-				return null;
+			if (typearg == null) {
+				//
+				// Pointer types are allowed without explicit unsafe, they are just tokens
+				//
+				using (ec.Set (ResolveContext.Options.UnsafeScope)) {
+					typearg = QueriedType.ResolveAsType (ec);
+				}
 
-			typearg = texpr.Type;
+				if (typearg == null)
+					return null;
 
-			if (typearg.Kind == MemberKind.Void && !(QueriedType is TypeExpression)) {
-				ec.Report.Error (673, loc, "System.Void cannot be used from C#. Use typeof (void) to get the void type object");
-			} else if (texpr is DynamicTypeExpr) {
-				ec.Report.Error (1962, QueriedType.Location,
-					"The typeof operator cannot be used on the dynamic type");
+				if (typearg.Kind == MemberKind.Void && !(QueriedType is TypeExpression)) {
+					ec.Report.Error (673, loc, "System.Void cannot be used from C#. Use typeof (void) to get the void type object");
+				} else if (typearg.BuiltinType == BuiltinTypeSpec.Type.Dynamic) {
+					ec.Report.Error (1962, QueriedType.Location,
+						"The typeof operator cannot be used on the dynamic type");
+				}
 			}
 
 			type = ec.BuiltinTypes.Type;
-			QueriedType = texpr;
 
 			// Even though what is returned is a type object, it's treated as a value by the compiler.
 			// In particular, 'typeof (Foo).X' is something totally different from 'Foo.X'.
@@ -7311,9 +7346,9 @@ namespace Mono.CSharp
 			if (targetType != type)
 				enc.Encode (type);
 
-			if (!(QueriedType is GenericOpenTypeExpr)) {
+			if (typearg is InflatedTypeSpec) {
 				var gt = typearg;
-				while (gt != null) {
+				do {
 					if (InflatedTypeSpec.ContainsTypeParameter (gt)) {
 						rc.Module.Compiler.Report.Error (416, loc, "`{0}': an attribute argument cannot use type parameters",
 							typearg.GetSignatureForError ());
@@ -7321,12 +7356,12 @@ namespace Mono.CSharp
 					}
 
 					gt = gt.DeclaringType;
-				}
+				} while (gt != null);
+			}
 
-				if (ContainsDynamicType (typearg)) {
-					Attribute.Error_AttributeArgumentIsDynamic (rc, loc);
-					return;
-				}
+			if (ContainsDynamicType (typearg)) {
+				Attribute.Error_AttributeArgumentIsDynamic (rc, loc);
+				return;
 			}
 
 			enc.EncodeTypeName (typearg);
@@ -7407,7 +7442,7 @@ namespace Mono.CSharp
 		{
 			Arguments args = new Arguments (2);
 			args.Add (new Argument (this));
-			args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+			args.Add (new Argument (new TypeOf (type, loc)));
 			return CreateExpressionFactoryCall (ec, "Constant", args);
 		}
 
@@ -7491,11 +7526,10 @@ namespace Mono.CSharp
 
 		protected override Expression DoResolve (ResolveContext ec)
 		{
-			TypeExpr texpr = QueriedType.ResolveAsType (ec);
-			if (texpr == null)
+			type_queried = QueriedType.ResolveAsType (ec);
+			if (type_queried == null)
 				return null;
 
-			type_queried = texpr.Type;
 			if (TypeManager.IsEnumType (type_queried))
 				type_queried = EnumSpec.GetUnderlyingType (type_queried);
 
@@ -7729,10 +7763,10 @@ namespace Mono.CSharp
 
 			Namespace ns = expr as Namespace;
 			if (ns != null) {
-				var retval = ns.LookupTypeOrNamespace (rc, Name, Arity, loc);
+				var retval = ns.LookupTypeOrNamespace (rc, Name, Arity, LookupMode.Normal, loc);
 
 				if (retval == null) {
-					ns.Error_NamespaceDoesNotExist (loc, Name, Arity, rc);
+					ns.Error_NamespaceDoesNotExist (rc, Name, Arity, loc);
 					return null;
 				}
 
@@ -7794,17 +7828,21 @@ namespace Mono.CSharp
 
 				if (errorMode) {
 					if (member_lookup == null) {
-						if (expr is TypeExpr)
+						var dep = expr_type.GetMissingDependencies ();
+						if (dep != null) {
+							ImportedTypeDefinition.Error_MissingDependency (rc, dep, loc);
+						} else if (expr is TypeExpr) {
 							base.Error_TypeDoesNotContainDefinition (rc, expr_type, Name);
-						else
+						} else {
 							Error_TypeDoesNotContainDefinition (rc, expr_type, Name);
+						}
 
 						return null;
 					}
 
 					if (member_lookup is MethodGroupExpr) {
 						// Leave it to overload resolution to report correct error
-					} else {
+					} else if (!(member_lookup is TypeExpr)) {
 						// TODO: rc.SymbolRelatedToPreviousError
 						ErrorIsInaccesible (rc, member_lookup.GetSignatureForError (), loc);
 					}
@@ -7857,7 +7895,7 @@ namespace Mono.CSharp
 				me.SetTypeArguments (rc, targs);
 			}
 
-			if (sn != null && (!TypeManager.IsValueType (expr_type) || me is PropertyExpr)) {
+			if (sn != null && (!TypeSpec.IsValueType (expr_type) || me is PropertyExpr)) {
 				if (me.IsInstance) {
 					LocalVariableReference var = expr as LocalVariableReference;
 					if (var != null && !var.VerifyAssigned (rc))
@@ -7871,8 +7909,10 @@ namespace Mono.CSharp
 		public override FullNamedExpression ResolveAsTypeOrNamespace (IMemberContext rc)
 		{
 			FullNamedExpression fexpr = expr as FullNamedExpression;
-			if (fexpr == null)
-				return expr.ResolveAsType (rc);
+			if (fexpr == null) {
+				expr.ResolveAsType (rc);
+				return null;
+			}
 
 			FullNamedExpression expr_resolved = fexpr.ResolveAsTypeOrNamespace (rc);
 
@@ -7881,22 +7921,24 @@ namespace Mono.CSharp
 
 			Namespace ns = expr_resolved as Namespace;
 			if (ns != null) {
-				FullNamedExpression retval = ns.LookupTypeOrNamespace (rc, Name, Arity, loc);
+				FullNamedExpression retval = ns.LookupTypeOrNamespace (rc, Name, Arity, LookupMode.Normal, loc);
 
 				if (retval == null) {
-					ns.Error_NamespaceDoesNotExist (loc, Name, Arity, rc);
+					ns.Error_NamespaceDoesNotExist (rc, Name, Arity, loc);
 				} else if (HasTypeArguments) {
-					retval = new GenericTypeExpr (retval.Type, targs, loc).ResolveAsType (rc);
+					retval = new GenericTypeExpr (retval.Type, targs, loc);
+					if (retval.ResolveAsType (rc) == null)
+						return null;
 				}
 
 				return retval;
 			}
 
-			TypeExpr tnew_expr = expr_resolved.ResolveAsType (rc);
+			var tnew_expr = expr_resolved.ResolveAsType (rc);
 			if (tnew_expr == null)
 				return null;
 
-			TypeSpec expr_type = tnew_expr.Type;
+			TypeSpec expr_type = tnew_expr;
 			if (TypeManager.IsGenericParameter (expr_type)) {
 				rc.Module.Compiler.Report.Error (704, loc, "A nested type cannot be specified through a type parameter `{0}'",
 					tnew_expr.GetSignatureForError ());
@@ -7907,12 +7949,12 @@ namespace Mono.CSharp
 			while (expr_type != null) {
 				nested = MemberCache.FindNestedType (expr_type, Name, Arity);
 				if (nested == null) {
-					if (expr_type == tnew_expr.Type) {
+					if (expr_type == tnew_expr) {
 						Error_IdentifierNotFound (rc, expr_type, Name);
 						return null;
 					}
 
-					expr_type = tnew_expr.Type;
+					expr_type = tnew_expr;
 					nested = MemberCache.FindNestedType (expr_type, Name, Arity);
 					ErrorIsInaccesible (rc, nested.GetSignatureForError (), loc);
 					break;
@@ -7936,7 +7978,10 @@ namespace Mono.CSharp
 				texpr = new TypeExpression (nested, loc);
 			}
 
-			return texpr.ResolveAsTypeOrNamespace (rc);
+			if (texpr.ResolveAsType (rc) == null)
+				return null;
+
+			return texpr;
 		}
 
 		protected virtual void Error_IdentifierNotFound (IMemberContext rc, TypeSpec expr_type, string identifier)
@@ -8424,6 +8469,10 @@ namespace Mono.CSharp
 			var ac = (ArrayContainer) ea.Expr.Type;
 
 			LoadArrayAndArguments (ec);
+
+			if (ac.Element.IsGenericParameter && mode == AddressOp.Load)
+				ec.Emit (OpCodes.Readonly);
+
 			ec.EmitArrayAddress (ac);
 		}
 
@@ -8837,7 +8886,31 @@ namespace Mono.CSharp
 		{
 			return visitor.Visit (this);
 		}
-	}	
+	}
+
+	class ErrorExpression : EmptyExpression
+	{
+		public static readonly ErrorExpression Instance = new ErrorExpression ();
+
+		private ErrorExpression ()
+			: base (InternalType.FakeInternalType)
+		{
+		}
+
+		public override Expression CreateExpressionTree (ResolveContext ec)
+		{
+			return this;
+		}
+
+		public override Expression DoResolveLValue (ResolveContext rc, Expression right_side)
+		{
+			return this;
+		}
+
+		public override void Error_ValueCannotBeConverted (ResolveContext ec, Location loc, TypeSpec target, bool expl)
+		{
+		}
+	}
 
 	public class UserCast : Expression {
 		MethodSpec method;
@@ -8861,7 +8934,7 @@ namespace Mono.CSharp
 		{
 			Arguments args = new Arguments (3);
 			args.Add (new Argument (source.CreateExpressionTree (ec)));
-			args.Add (new Argument (new TypeOf (new TypeExpression (type, loc), loc)));
+			args.Add (new Argument (new TypeOf (type, loc)));
 			args.Add (new Argument (new TypeOfMethod (method, loc)));
 			return CreateExpressionFactoryCall (ec, "Convert", args);
 		}
@@ -8986,22 +9059,20 @@ namespace Mono.CSharp
 			this.loc = spec.Location;
 		}
 
-		public override TypeExpr ResolveAsType (IMemberContext ec)
+		public override TypeSpec ResolveAsType (IMemberContext ec)
 		{
-			TypeExpr lexpr = left.ResolveAsType (ec);
-			if (lexpr == null)
+			type = left.ResolveAsType (ec);
+			if (type == null)
 				return null;
 
-			type = lexpr.Type;
 			eclass = ExprClass.Type;
 
 			var single_spec = spec;
 
 			if (single_spec.IsNullable) {
-				lexpr = new Nullable.NullableType (lexpr, loc);
-				lexpr = lexpr.ResolveAsType (ec);
-				if (lexpr != null)
-					type = lexpr.Type;
+				type = new Nullable.NullableType (type, loc).ResolveAsType (ec);
+				if (type == null)
+					return null;
 
 				single_spec = single_spec.Next;
 			} else if (single_spec.IsPointer) {
@@ -9030,7 +9101,7 @@ namespace Mono.CSharp
 				}
 			}
 
-			return this;
+			return type;
 		}
 
 		void MakeArray (ModuleContainer module, ComposedTypeSpecifier spec)
@@ -9192,12 +9263,10 @@ namespace Mono.CSharp
 				ec.Report.Error (255, loc, "Cannot use stackalloc in finally or catch");
 			}
 
-			TypeExpr texpr = t.ResolveAsType (ec);
-			if (texpr == null)
+			otype = t.ResolveAsType (ec);
+			if (otype == null)
 				return null;
 
-			otype = texpr.Type;
-
 			if (!TypeManager.VerifyUnmanaged (ec.Module, otype, loc))
 				return null;
 
@@ -9862,4 +9931,43 @@ namespace Mono.CSharp
 				Name, initializer);
 		}
 	}
+
+	class Await : ExpressionStatement
+	{
+		Expression expr;
+
+		public Await (Expression expr, Location loc)
+		{
+			this.expr = expr;
+			this.loc = loc;
+		}
+
+		public override Expression CreateExpressionTree (ResolveContext ec)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override void Emit (EmitContext ec)
+		{
+			throw new NotImplementedException ();
+		}
+
+		public override void EmitStatement (EmitContext ec)
+		{
+			throw new NotImplementedException ();
+		}
+
+		protected override Expression DoResolve (ResolveContext rc)
+		{
+			expr = expr.Resolve (rc);
+			if (expr == null)
+				return null;
+
+//			Iterator.CreateIterator
+
+			type = expr.Type;
+			eclass = expr.eclass;
+			return this;
+		}
+	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/field.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/field.cs
index 077375c41..b81854695 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/field.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/field.cs
@@ -171,7 +171,8 @@ namespace Mono.CSharp
  				return false;
 
 			MemberSpec candidate;
-			var conflict_symbol = MemberCache.FindBaseMember (this, out candidate);
+			bool overrides = false;
+			var conflict_symbol = MemberCache.FindBaseMember (this, out candidate, ref overrides);
 			if (conflict_symbol == null)
 				conflict_symbol = candidate;
 
@@ -242,6 +243,8 @@ namespace Mono.CSharp
 				Report.Error (625, Location, "`{0}': Instance field types marked with StructLayout(LayoutKind.Explicit) must have a FieldOffset attribute", GetSignatureForError ());
 			}
 
+			ConstraintChecker.Check (this, member_type, type_expr.Location);
+
 			base.Emit ();
 		}
 
@@ -577,9 +580,6 @@ namespace Mono.CSharp
 
 		bool CanBeVolatile ()
 		{
-			if (TypeManager.IsReferenceType (MemberType))
-				return true;
-
 			switch (MemberType.BuiltinType) {
 			case BuiltinTypeSpec.Type.Bool:
 			case BuiltinTypeSpec.Type.Char:
@@ -595,6 +595,9 @@ namespace Mono.CSharp
 				return true;
 			}
 
+			if (TypeSpec.IsReferenceType (MemberType))
+				return true;
+
 			if (MemberType.IsEnum)
 				return true;
 
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/generic.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/generic.cs
index 0eb735f3e..c96f2d0e7 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/generic.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/generic.cs
@@ -133,12 +133,23 @@ namespace Mono.CSharp {
 			return false;
 		}
 
-		public void CheckGenericConstraints (IMemberContext context)
+		public void CheckGenericConstraints (IMemberContext context, bool obsoleteCheck)
 		{
 			foreach (var c in constraints) {
-				var ge = c as GenericTypeExpr;
-				if (ge != null)
-					ge.CheckConstraints (context);
+				if (c == null)
+					continue;
+
+				var t = c.Type;
+				if (t == null)
+					continue;
+
+				if (obsoleteCheck) {
+					ObsoleteAttribute obsolete_attr = t.GetAttributeObsolete ();
+					if (obsolete_attr != null)
+						AttributeTester.Report_ObsoleteMessage (obsolete_attr, t.GetSignatureForError (), c.Location, context.Module.Compiler.Report);
+				}
+
+				ConstraintChecker.Check (context, t, c.Location);
 			}
 		}
 
@@ -174,19 +185,16 @@ namespace Mono.CSharp {
 					continue;
 				}
 
-				var type_expr = constraints[i] = constraint.ResolveAsType (context);
-				if (type_expr == null)
+				var type = constraint.ResolveAsType (context);
+				if (type == null)
 					continue;
 
-				var gexpr = type_expr as GenericTypeExpr;
-				if (gexpr != null && gexpr.HasDynamicArguments ()) {
+				if (type.Arity > 0 && ((InflatedTypeSpec) type).HasDynamicArgument ()) {
 					context.Module.Compiler.Report.Error (1968, constraint.Location,
-						"A constraint cannot be the dynamic type `{0}'", gexpr.GetSignatureForError ());
+						"A constraint cannot be the dynamic type `{0}'", type.GetSignatureForError ());
 					continue;
 				}
 
-				var type = type_expr.Type;
-
 				if (!context.CurrentMemberDefinition.IsAccessibleAs (type)) {
 					context.Module.Compiler.Report.SymbolRelatedToPreviousError (type);
 					context.Module.Compiler.Report.Error (703, loc,
@@ -273,7 +281,7 @@ namespace Mono.CSharp {
 				}
 
 				if (spec.HasSpecialStruct || spec.HasSpecialClass) {
-					context.Module.Compiler.Report.Error (450, type_expr.Location,
+					context.Module.Compiler.Report.Error (450, constraint.Location,
 						"`{0}': cannot specify both a constraint class and the `class' or `struct' constraint",
 						type.GetSignatureForError ());
 				}
@@ -472,10 +480,10 @@ namespace Mono.CSharp {
 			builder.SetCustomAttribute ((ConstructorInfo) ctor.GetMetaInfo (), cdata);
 		}
 
-		public void CheckGenericConstraints ()
+		public void CheckGenericConstraints (bool obsoleteCheck)
 		{
 			if (constraints != null)
-				constraints.CheckGenericConstraints (this);
+				constraints.CheckGenericConstraints (this, obsoleteCheck);
 		}
 
 		public TypeParameter CreateHoistedCopy (TypeContainer declaringType, TypeSpec declaringSpec)
@@ -588,7 +596,7 @@ namespace Mono.CSharp {
 
 		bool ITypeDefinition.IsInternalAsPublic (IAssemblyDefinition assembly)
 		{
-			return spec.GetEffectiveBase ().MemberDefinition.DeclaringAssembly == assembly;
+			return spec.MemberDefinition.DeclaringAssembly == assembly;
 		}
 
 		public void LoadMembers (TypeSpec declaringType, bool onlyTypes, ref MemberCache cache)
@@ -747,16 +755,29 @@ namespace Mono.CSharp {
 		}
 
 		//
-		// Returns whether the type parameter is "known to be a reference type"
+		// Returns whether the type parameter is known to be a reference type
 		//
-		public bool IsReferenceType {
+		public new bool IsReferenceType {
 			get {
-				if ((spec & SpecialConstraint.Class) != 0 || HasTypeConstraint)
+				if ((spec & (SpecialConstraint.Class | SpecialConstraint.Struct)) != 0)
+					return (spec & SpecialConstraint.Class) != 0;
+
+				//
+				// Full check is needed (see IsValueType for details)
+				//
+				if (HasTypeConstraint && TypeSpec.IsReferenceType (BaseType))
 					return true;
 
 				if (targs != null) {
 					foreach (var ta in targs) {
-						if (TypeManager.IsReferenceType (ta))
+						//
+						// Secondary special constraints are ignored (I am not sure why)
+						//
+						var tp = ta as TypeParameterSpec;
+						if (tp != null && (tp.spec & (SpecialConstraint.Class | SpecialConstraint.Struct)) != 0)
+							continue;
+
+						if (TypeSpec.IsReferenceType (ta))
 							return true;
 					}
 				}
@@ -765,10 +786,21 @@ namespace Mono.CSharp {
 			}
 		}
 
-		public bool IsValueType {	// TODO: Do I need this ?
+		//
+		// Returns whether the type parameter is known to be a value type
+		//
+		public new bool IsValueType {
 			get {
-				// TODO MemberCache: probably wrong
-				return HasSpecialStruct;
+				//
+				// Even if structs/enums cannot be used directly as constraints
+				// they can apear as constraint type when inheriting base constraint
+				// which has dependant type parameter constraint which has been
+				// inflated using value type
+				//
+				// class A : B<int> { override void Foo<U> () {} }
+				// class B<T> { virtual void Foo<U> () where U : T {} }
+				//
+				return HasSpecialStruct || TypeSpec.IsValueType (BaseType);
 			}
 		}
 
@@ -835,15 +867,27 @@ namespace Mono.CSharp {
 		}
 
 		//
-		// Finds effective base class
+		// Finds effective base class. The effective base class is always a class-type
 		//
 		public TypeSpec GetEffectiveBase ()
 		{
 			if (HasSpecialStruct)
 				return BaseType;
 
-			if (BaseType != null && targs == null)
-				return BaseType;
+			//
+			// If T has a class-type constraint C but no type-parameter constraints, its effective base class is C
+			//
+			if (BaseType != null && targs == null) {
+				//
+				// If T has a constraint V that is a value-type, use instead the most specific base type of V that is a class-type.
+				// 
+				// LAMESPEC: Is System.ValueType always the most specific base type in this case?
+				//
+				// Note: This can never happen in an explicitly given constraint, but may occur when the constraints of a generic method
+				// are implicitly inherited by an overriding method declaration or an explicit implementation of an interface method.
+				//
+				return BaseType.IsStruct ? BaseType.BaseType : BaseType;
+			}
 
 			var types = targs;
 			if (HasTypeConstraint) {
@@ -1218,6 +1262,14 @@ namespace Mono.CSharp {
 				// 
 				targs = type.TypeArguments;
 
+				//
+				// When inflating imported nested type used inside same declaring type, we get TypeSpec
+				// because the import cache helps us to catch it. However, that means we have to look at
+				// type definition to get type argument (they are in fact type parameter in this case)
+				//
+				if (targs.Length == 0 && type.Arity > 0)
+					targs = type.MemberDefinition.TypeParameters;
+
 				//
 				// Parent was inflated, find the same type on inflated type
 				// to use same cache for nested types on same generic parent
@@ -1403,6 +1455,9 @@ namespace Mono.CSharp {
 
 			if (open_type.Kind == MemberKind.MissingType)
 				MemberCache = MemberCache.Empty;
+
+			if ((open_type.Modifiers & Modifiers.COMPILER_GENERATED) != 0)
+				state |= StateFlags.ConstraintsChecked;
 		}
 
 		#region Properties
@@ -1429,6 +1484,18 @@ namespace Mono.CSharp {
 			}
 		}
 
+		//
+		// Used to cache expensive constraints validation on constructed types
+		//
+		public bool HasConstraintsChecked {
+			get {
+				return (state & StateFlags.ConstraintsChecked) != 0;
+			}
+			set {
+				state = value ? state | StateFlags.ConstraintsChecked : state & ~StateFlags.ConstraintsChecked;
+			}
+		}
+
 		public override IList<TypeSpec> Interfaces {
 			get {
 				if (cache == null)
@@ -1608,6 +1675,34 @@ namespace Mono.CSharp {
 			return "<" + TypeManager.CSharpName (targs) + ">";
 		}
 
+		public bool HasDynamicArgument ()
+		{
+			for (int i = 0; i < targs.Length; ++i) {
+				var item = targs[i];
+
+				if (item.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+					return true;
+
+				if (item is InflatedTypeSpec) {
+					if (((InflatedTypeSpec) item).HasDynamicArgument ())
+						return true;
+
+					continue;
+				}
+
+				if (item.IsArray) {
+					while (item.IsArray) {
+						item = ((ArrayContainer) item).Element;
+					}
+
+					if (item.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
+						return true;
+				}
+			}
+
+			return false;
+		}
+
 		protected override void InitializeMemberCache (bool onlyTypes)
 		{
 			if (cache == null) {
@@ -1762,6 +1857,9 @@ namespace Mono.CSharp {
 			get {
 				return atypes;
 			}
+			set {
+				atypes = value;
+			}
 		}
 
 		public int Count {
@@ -1805,22 +1903,22 @@ namespace Mono.CSharp {
 			atypes = new TypeSpec [count];
 
 			for (int i = 0; i < count; i++){
-				TypeExpr te = args[i].ResolveAsType (ec);
+				var te = args[i].ResolveAsType (ec);
 				if (te == null) {
 					ok = false;
 					continue;
 				}
 
-				atypes[i] = te.Type;
+				atypes[i] = te;
 
-				if (te.Type.IsStatic) {
-					ec.Module.Compiler.Report.Error (718, te.Location, "`{0}': static classes cannot be used as generic arguments",
+				if (te.IsStatic) {
+					ec.Module.Compiler.Report.Error (718, args[i].Location, "`{0}': static classes cannot be used as generic arguments",
 						te.GetSignatureForError ());
 					ok = false;
 				}
 
-				if (te.Type.IsPointer || te.Type.IsSpecialRuntimeType) {
-					ec.Module.Compiler.Report.Error (306, te.Location,
+				if (te.IsPointer || te.IsSpecialRuntimeType) {
+					ec.Module.Compiler.Report.Error (306, args[i].Location,
 						"The type `{0}' may not be used as a type argument",
 						te.GetSignatureForError ());
 					ok = false;
@@ -1900,7 +1998,6 @@ namespace Mono.CSharp {
 	{
 		TypeArguments args;
 		TypeSpec open_type;
-		bool constraints_checked;
 
 		/// <summary>
 		///   Instantiate the generic type `t' with the type arguments `args'.
@@ -1923,9 +2020,12 @@ namespace Mono.CSharp {
 			return TypeManager.CSharpName (type);
 		}
 
-		public override TypeExpr ResolveAsType (IMemberContext ec)
+		public override TypeSpec ResolveAsType (IMemberContext mc)
 		{
-			if (!args.Resolve (ec))
+			if (eclass != ExprClass.Unresolved)
+				return type;
+
+			if (!args.Resolve (mc))
 				return null;
 
 			TypeSpec[] atypes = args.Arguments;
@@ -1933,67 +2033,24 @@ namespace Mono.CSharp {
 			//
 			// Now bind the parameters
 			//
-			type = open_type.MakeGenericType (ec, atypes);
+			var inflated = open_type.MakeGenericType (mc, atypes);
+			type = inflated;
 			eclass = ExprClass.Type;
 
 			//
-			// Check constraints when context is not method/base type
+			// The constraints can be checked only when full type hierarchy is known
 			//
-			if (!ec.HasUnresolvedConstraints)
-				CheckConstraints (ec);
-
-			return this;
-		}
-
-		//
-		// Checks the constraints of open generic type against type
-		// arguments. Has to be called after all members have been defined
-		//
-		public bool CheckConstraints (IMemberContext ec)
-		{
-			if (constraints_checked)
-				return true;
-
-			constraints_checked = true;
-
-			if ((type.Modifiers & Modifiers.COMPILER_GENERATED) != 0)
-				return true;
-
-			var gtype = (InflatedTypeSpec) type;
-			var constraints = gtype.Constraints;
-			if (constraints == null)
-				return true;
-
-			return new ConstraintChecker(ec).CheckAll (open_type, args.Arguments, constraints, loc);
-		}
-
-		public bool HasDynamicArguments ()
-		{
-			return HasDynamicArguments (args.Arguments);
-		}
-
-		static bool HasDynamicArguments (TypeSpec[] args)
-		{
-			for (int i = 0; i < args.Length; ++i) {
-				var item = args[i];
-
-				if (item.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
-					return true;
-
-				if (TypeManager.IsGenericType (item))
-					return HasDynamicArguments (TypeManager.GetTypeArguments (item));
-
-				if (item.IsArray) {
-					while (item.IsArray) {
-						item = ((ArrayContainer) item).Element;
+			if (!inflated.HasConstraintsChecked && mc.Module.HasTypesFullyDefined) {
+				var constraints = inflated.Constraints;
+				if (constraints != null) {
+					var cc = new ConstraintChecker (mc);
+					if (cc.CheckAll (open_type, atypes, constraints, loc)) {
+						inflated.HasConstraintsChecked = true;
 					}
-
-					if (item.BuiltinType == BuiltinTypeSpec.Type.Dynamic)
-						return true;
 				}
 			}
 
-			return false;
+			return type;
 		}
 
 		public override bool Equals (object obj)
@@ -2029,11 +2086,13 @@ namespace Mono.CSharp {
 	{
 		IMemberContext mc;
 		bool ignore_inferred_dynamic;
+		bool recursive_checks;
 
 		public ConstraintChecker (IMemberContext ctx)
 		{
 			this.mc = ctx;
 			ignore_inferred_dynamic = false;
+			recursive_checks = false;
 		}
 
 		#region Properties
@@ -2049,6 +2108,48 @@ namespace Mono.CSharp {
 
 		#endregion
 
+		//
+		// Checks the constraints of open generic type against type
+		// arguments. This version is used for types which could not be
+		// checked immediatelly during construction because the type
+		// hierarchy was not yet fully setup (before Emit phase)
+		//
+		public static bool Check (IMemberContext mc, TypeSpec type, Location loc)
+		{
+			//
+			// Check declaring type first if there is any
+			//
+			if (type.DeclaringType != null && !Check (mc, type.DeclaringType, loc))
+				return false;
+
+			while (type is ElementTypeSpec)
+				type = ((ElementTypeSpec) type).Element;
+
+			if (type.Arity == 0)
+				return true;
+
+			var gtype = type as InflatedTypeSpec;
+			if (gtype == null)
+				return true;
+
+			var constraints = gtype.Constraints;
+			if (constraints == null)
+				return true;
+
+			if (gtype.HasConstraintsChecked)
+				return true;
+
+			var cc = new ConstraintChecker (mc);
+			cc.recursive_checks = true;
+
+			if (cc.CheckAll (gtype.GetDefinition (), type.TypeArguments, constraints, loc)) {
+				gtype.HasConstraintsChecked = true;
+				return true;
+			}
+
+			return false;
+		}
+
 		//
 		// Checks all type arguments againts type parameters constraints
 		// NOTE: It can run in probing mode when `mc' is null
@@ -2059,7 +2160,14 @@ namespace Mono.CSharp {
 				if (ignore_inferred_dynamic && targs[i].BuiltinType == BuiltinTypeSpec.Type.Dynamic)
 					continue;
 
-				if (!CheckConstraint (context, targs [i], tparams [i], loc))
+				var targ = targs[i];
+				if (!CheckConstraint (context, targ, tparams [i], loc))
+					return false;
+
+				if (!recursive_checks)
+					continue;
+
+				if (!Check (mc, targ, loc))
 					return false;
 			}
 
@@ -2071,7 +2179,7 @@ namespace Mono.CSharp {
 			//
 			// First, check the `class' and `struct' constraints.
 			//
-			if (tparam.HasSpecialClass && !TypeManager.IsReferenceType (atype)) {
+			if (tparam.HasSpecialClass && !TypeSpec.IsReferenceType (atype)) {
 				if (mc != null) {
 					mc.Module.Compiler.Report.Error (452, loc,
 						"The type `{0}' must be a reference type in order to use it as type parameter `{1}' in the generic type or method `{2}'",
@@ -2081,7 +2189,7 @@ namespace Mono.CSharp {
 				return false;
 			}
 
-			if (tparam.HasSpecialStruct && (!TypeManager.IsValueType (atype) || atype.IsNullableType)) {
+			if (tparam.HasSpecialStruct && (!TypeSpec.IsValueType (atype) || atype.IsNullableType)) {
 				if (mc != null) {
 					mc.Module.Compiler.Report.Error (453, loc,
 						"The type `{0}' must be a non-nullable value type in order to use it as type parameter `{1}' in the generic type or method `{2}'",
@@ -2200,15 +2308,27 @@ namespace Mono.CSharp {
 
 		bool CheckConversion (IMemberContext mc, MemberSpec context, TypeSpec atype, TypeParameterSpec tparam, TypeSpec ttype, Location loc)
 		{
-			if (TypeManager.IsValueType (atype)) {
-				if (atype == ttype || Convert.ImplicitBoxingConversion (null, atype, ttype) != null)
+			if (atype == ttype)
+				return true;
+
+			if (atype.IsGenericParameter) {
+				var tps = (TypeParameterSpec) atype;
+				if (Convert.ImplicitTypeParameterConversion (null, tps, ttype) != null)
+					return true;
+
+				//
+				// LAMESPEC: Identity conversion with inflated type parameter
+				// It's not clear from the spec what rule should apply to inherited
+				// inflated type parameter. The specification allows only type parameter
+				// conversion but that's clearly not enough
+				//
+				if (tps.HasTypeConstraint && tps.BaseType == ttype)
 					return true;
-			} else {
-				if (atype.IsGenericParameter) {
-					if (Convert.ImplicitTypeParameterConversion (null, (TypeParameterSpec) atype, ttype) != null)
-						return true;
-				}
 
+			} else if (TypeSpec.IsValueType (atype)) {
+				if (Convert.ImplicitBoxingConversion (null, atype, ttype) != null)
+					return true;
+			} else {
 				var expr = new EmptyExpression (atype);
 				if (Convert.ImplicitStandardConversionExists (expr, ttype))
 					return true;
@@ -2224,14 +2344,14 @@ namespace Mono.CSharp {
 
 			if (mc != null) {
 				mc.Module.Compiler.Report.SymbolRelatedToPreviousError (tparam);
-				if (TypeManager.IsValueType (atype)) {
-					mc.Module.Compiler.Report.Error (315, loc,
-						"The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing conversion from `{0}' to `{3}'",
-						atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError (), ttype.GetSignatureForError ());
-				} else if (atype.IsGenericParameter) {
+				if (atype.IsGenericParameter) {
 					mc.Module.Compiler.Report.Error (314, loc,
 						"The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing or type parameter conversion from `{0}' to `{3}'",
 						atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError (), ttype.GetSignatureForError ());
+				} else if (TypeSpec.IsValueType (atype)) {
+					mc.Module.Compiler.Report.Error (315, loc,
+						"The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no boxing conversion from `{0}' to `{3}'",
+						atype.GetSignatureForError (), tparam.GetSignatureForError (), context.GetSignatureForError (), ttype.GetSignatureForError ());
 				} else {
 					mc.Module.Compiler.Report.Error (311, loc,
 						"The type `{0}' cannot be used as type parameter `{1}' in the generic type or method `{2}'. There is no implicit reference conversion from `{0}' to `{3}'",
@@ -2257,30 +2377,6 @@ namespace Mono.CSharp {
 
 			var tdef = atype.GetDefinition ();
 
-			//
-			// In some circumstances MemberCache is not yet populated and members
-			// cannot be defined yet (recursive type new constraints)
-			//
-			// class A<T> where T : B<T>, new () {}
-			// class B<T> where T : A<T>, new () {}
-			//
-			var tc = tdef.MemberDefinition as Class;
-			if (tc != null) {
-				if (tc.InstanceConstructors == null) {
-					// Default ctor will be generated later
-					return true;
-				}
-
-				foreach (var c in tc.InstanceConstructors) {
-					if (c.ParameterInfo.IsEmpty) {
-						if ((c.ModFlags & Modifiers.PUBLIC) != 0)
-							return true;
-					}
-				}
-
-				return false;
-			}
-
 			var found = MemberCache.FindMember (tdef,
 				MemberFilter.Constructor (ParametersCompiled.EmptyReadOnlyParameters),
 				BindingRestriction.DeclaredOnly | BindingRestriction.InstanceOnly);
@@ -2531,7 +2627,7 @@ namespace Mono.CSharp {
 				if (a.Expr.Type == InternalType.NullLiteral)
 					continue;
 
-				if (TypeManager.IsValueType (method_parameter)) {
+				if (TypeSpec.IsValueType (method_parameter)) {
 					score -= tic.LowerBoundInference (a.Type, method_parameter);
 					continue;
 				}
@@ -2686,7 +2782,7 @@ namespace Mono.CSharp {
 			//
 			// Some types cannot be used as type arguments
 			//
-			if (bound.Type.Kind == MemberKind.Void || bound.Type.IsPointer)
+			if (bound.Type.Kind == MemberKind.Void || bound.Type.IsPointer || bound.Type.IsSpecialRuntimeType)
 				return;
 
 			var a = bounds [index];
@@ -2815,6 +2911,9 @@ namespace Mono.CSharp {
 
 				var invoke = Delegate.GetInvokeMethod (t);
 				TypeSpec rtype = invoke.ReturnType;
+				while (rtype.IsArray)
+					rtype = ((ArrayContainer) rtype).Element;
+
 				if (!rtype.IsGenericParameter && !TypeManager.IsGenericType (rtype))
 					continue;
 
@@ -3011,6 +3110,9 @@ namespace Mono.CSharp {
 		//
 		public bool IsReturnTypeNonDependent (ResolveContext ec, MethodSpec invoke, TypeSpec returnType)
 		{
+			while (returnType.IsArray)
+				returnType = ((ArrayContainer) returnType).Element;
+
 			if (returnType.IsGenericParameter) {
 				if (IsFixed (returnType))
 				    return false;
@@ -3084,7 +3186,7 @@ namespace Mono.CSharp {
 					if (u_ac.Rank != v_ac.Rank)
 						return 0;
 
-					if (TypeManager.IsValueType (u_ac.Element))
+					if (TypeSpec.IsValueType (u_ac.Element))
 						return ExactInference (u_ac.Element, v_ac.Element);
 
 					return LowerBoundInference (u_ac.Element, v_ac.Element, inversed);
@@ -3094,7 +3196,7 @@ namespace Mono.CSharp {
 					return 0;
 
 				var v_i = TypeManager.GetTypeArguments (v) [0];
-				if (TypeManager.IsValueType (u_ac.Element))
+				if (TypeSpec.IsValueType (u_ac.Element))
 					return ExactInference (u_ac.Element, v_i);
 
 				return LowerBoundInference (u_ac.Element, v_i);
@@ -3174,7 +3276,7 @@ namespace Mono.CSharp {
 						Variance variance = ga_open_v [i].Variance;
 
 						TypeSpec u_i = unique_candidate_targs [i];
-						if (variance == Variance.None || TypeManager.IsValueType (u_i)) {
+						if (variance == Variance.None || TypeSpec.IsValueType (u_i)) {
 							if (ExactInference (u_i, ga_v [i]) == 0)
 								++score;
 						} else {
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/import.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/import.cs
index 834134f48..c8a49cfcd 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/import.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/import.cs
@@ -87,10 +87,9 @@ namespace Mono.CSharp
 				}
 
 				if (cad.Count > 0) {
-					string ns, name;
 					foreach (var ca in cad) {
-						importer.GetCustomAttributeTypeName (ca, out ns, out name);
-						if (name != "DynamicAttribute" && ns != CompilerServicesNamespace)
+						var dt = ca.Constructor.DeclaringType;
+						if (dt.Name != "DynamicAttribute" && dt.Namespace != CompilerServicesNamespace)
 							continue;
 
 						if (ca.ConstructorArguments.Count == 0) {
@@ -149,7 +148,6 @@ namespace Mono.CSharp
 		public abstract void AddCompiledType (TypeBuilder builder, TypeSpec spec);
 		protected abstract MemberKind DetermineKindFromBaseType (MetaType baseType);
 		protected abstract bool HasVolatileModifier (MetaType[] modifiers);
-		public abstract void GetCustomAttributeTypeName (CustomAttributeData cad, out string typeNamespace, out string typeName);
 
 		public FieldSpec CreateField (FieldInfo fi, TypeSpec declaringType)
 		{
@@ -479,7 +477,7 @@ namespace Mono.CSharp
 					if (!is_params && p.IsOptional) {
 						object value = p.RawDefaultValue;
 						var ptype = types[i];
-						if ((p.Attributes & ParameterAttributes.HasDefault) != 0 && ptype.Kind != MemberKind.TypeParameter && (value != null || TypeManager.IsReferenceType (ptype))) {
+						if ((p.Attributes & ParameterAttributes.HasDefault) != 0 && ptype.Kind != MemberKind.TypeParameter && (value != null || TypeSpec.IsReferenceType (ptype))) {
 							if (value == null) {
 								default_value = Constant.CreateConstant (ptype, null, Location.Null);
 							} else {
@@ -683,6 +681,11 @@ namespace Mono.CSharp
 
 			if (type.IsGenericType && !type.IsGenericTypeDefinition) {
 				var type_def = type.GetGenericTypeDefinition ();
+
+				// Generic type definition can also be forwarded
+				if (compiled_types.TryGetValue (type_def, out spec))
+					return spec;
+
 				var targs = CreateGenericArguments (0, type.GetGenericArguments (), dtype);
 				if (declaringType == null) {
 					// Simple case, no nesting
@@ -848,7 +851,7 @@ namespace Mono.CSharp
 			if (!assembly_2_definition.TryGetValue (assembly, out found)) {
 
 				// This can happen in dynamic context only
-				var def = new ImportedAssemblyDefinition (assembly, this);
+				var def = new ImportedAssemblyDefinition (assembly);
 				assembly_2_definition.Add (assembly, def);
 				def.ReadAttributes ();
 				found = def;
@@ -912,10 +915,9 @@ namespace Mono.CSharp
 			if (attributesData.Count == 0)
 				return false;
 
-			string ns, name;
 			foreach (var attr in attributesData) {
-				GetCustomAttributeTypeName (attr, out ns, out name);
-				if (name == attrName && ns == attrNamespace)
+				var dt = attr.Constructor.DeclaringType;
+				if (dt.Name == attrName && dt.Namespace == attrNamespace)
 					return true;
 			}
 
@@ -1128,10 +1130,9 @@ namespace Mono.CSharp
 			if (attrs.Count == 0)
 				return null;
 
-			string name, ns;
 			foreach (var ca in attrs) {
-				GetCustomAttributeTypeName (ca, out ns, out name);
-				if (name != "DecimalConstantAttribute" || ns != CompilerServicesNamespace)
+				var dt = ca.Constructor.DeclaringType;
+				if (dt.Name != "DecimalConstantAttribute" || dt.Namespace != CompilerServicesNamespace)
 					continue;
 
 				var value = new decimal (
@@ -1223,11 +1224,11 @@ namespace Mono.CSharp
 				// It should not throw any loading exception
 				IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes (mi);
 
-				string ns, name;
 				foreach (var a in attrs) {
-					importer.GetCustomAttributeTypeName (a, out ns, out name);
+					var dt = a.Constructor.DeclaringType;
+					string name = dt.Name;
 					if (name == "ObsoleteAttribute") {
-						if (ns != "System")
+						if (dt.Namespace != "System")
 							continue;
 
 						if (bag == null)
@@ -1247,7 +1248,7 @@ namespace Mono.CSharp
 					}
 
 					if (name == "ConditionalAttribute") {
-						if (ns != "System.Diagnostics")
+						if (dt.Namespace != "System.Diagnostics")
 							continue;
 
 						if (bag == null)
@@ -1261,7 +1262,7 @@ namespace Mono.CSharp
 					}
 
 					if (name == "CLSCompliantAttribute") {
-						if (ns != "System")
+						if (dt.Namespace != "System")
 							continue;
 
 						if (bag == null)
@@ -1274,7 +1275,7 @@ namespace Mono.CSharp
 					// Type only attributes
 					if (mi.MemberType == MemberTypes.TypeInfo || mi.MemberType == MemberTypes.NestedType) {
 						if (name == "DefaultMemberAttribute") {
-							if (ns != "System.Reflection")
+							if (dt.Namespace != "System.Reflection")
 								continue;
 
 							if (bag == null)
@@ -1285,7 +1286,7 @@ namespace Mono.CSharp
 						}
 
 						if (name == "AttributeUsageAttribute") {
-							if (ns != "System")
+							if (dt.Namespace != "System")
 								continue;
 
 							if (bag == null)
@@ -1303,7 +1304,7 @@ namespace Mono.CSharp
 
 						// Interface only attribute
 						if (name == "CoClassAttribute") {
-							if (ns != "System.Runtime.InteropServices")
+							if (dt.Namespace != "System.Runtime.InteropServices")
 								continue;
 
 							if (bag == null)
@@ -1396,12 +1397,10 @@ namespace Mono.CSharp
 	{
 		readonly Module module;
 		bool cls_compliant;
-		readonly MetadataImporter importer;
 		
-		public ImportedModuleDefinition (Module module, MetadataImporter importer)
+		public ImportedModuleDefinition (Module module)
 		{
 			this.module = module;
-			this.importer = importer;
 		}
 
 		#region Properties
@@ -1424,11 +1423,10 @@ namespace Mono.CSharp
 		{
 			IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes (module);
 
-			string ns, name;
 			foreach (var a in attrs) {
-				importer.GetCustomAttributeTypeName (a, out ns, out name);
-				if (name == "CLSCompliantAttribute") {
-					if (ns != "System")
+				var dt = a.Constructor.DeclaringType;
+				if (dt.Name == "CLSCompliantAttribute") {
+					if (dt.Namespace != "System")
 						continue;
 
 					cls_compliant = (bool) a.ConstructorArguments[0].Value;
@@ -1477,18 +1475,16 @@ namespace Mono.CSharp
 	{
 		readonly Assembly assembly;
 		readonly AssemblyName aname;
-		readonly MetadataImporter importer;
 		bool cls_compliant;
 		bool contains_extension_methods;
 
 		List<AssemblyName> internals_visible_to;
 		Dictionary<IAssemblyDefinition, AssemblyName> internals_visible_to_cache;
 
-		public ImportedAssemblyDefinition (Assembly assembly, MetadataImporter importer)
+		public ImportedAssemblyDefinition (Assembly assembly)
 		{
 			this.assembly = assembly;
 			this.aname = assembly.GetName ();
-			this.importer = importer;
 		}
 
 		#region Properties
@@ -1603,31 +1599,21 @@ namespace Mono.CSharp
 
 			IList<CustomAttributeData> attrs = CustomAttributeData.GetCustomAttributes (assembly);
 
-			string ns, name;
 			foreach (var a in attrs) {
-				importer.GetCustomAttributeTypeName (a, out ns, out name);
-
+				var dt = a.Constructor.DeclaringType;
+				var name = dt.Name;
 				if (name == "CLSCompliantAttribute") {
-					if (ns == "System") {
-						try {
-							cls_compliant = (bool) a.ConstructorArguments[0].Value;
-						} catch {
-						}
+					if (dt.Namespace == "System") {
+						cls_compliant = (bool) a.ConstructorArguments[0].Value;
 					}
 					continue;
 				}
 
 				if (name == "InternalsVisibleToAttribute") {
-					if (ns != MetadataImporter.CompilerServicesNamespace)
+					if (dt.Namespace != MetadataImporter.CompilerServicesNamespace)
 						continue;
 
-					string s;
-					try {
-						s = a.ConstructorArguments[0].Value as string;
-					} catch {
-						s = null;
-					}
-
+					string s = a.ConstructorArguments[0].Value as string;
 					if (s == null)
 						continue;
 
@@ -1640,7 +1626,7 @@ namespace Mono.CSharp
 				}
 
 				if (name == "ExtensionAttribute") {
-					if (ns == MetadataImporter.CompilerServicesNamespace)
+					if (dt.Namespace == MetadataImporter.CompilerServicesNamespace)
 						contains_extension_methods = true;
 
 					continue;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/iterators.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/iterators.cs
index a02665c06..f3bab35e2 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/iterators.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/iterators.cs
@@ -313,6 +313,7 @@ namespace Mono.CSharp {
 		TypeExpr iterator_type_expr;
 		Field pc_field;
 		Field current_field;
+		Field disposing_field;
 
 		TypeExpr enumerator_type;
 		TypeExpr enumerable_type;
@@ -331,7 +332,15 @@ namespace Mono.CSharp {
 		}
 
 		public Field PC {
-			get { return pc_field; }
+			get {
+				return pc_field;
+			}
+		}
+
+		public Field DisposingField {
+			get {
+				return disposing_field;
+			}
 		}
 
 		public Field CurrentField {
@@ -342,7 +351,7 @@ namespace Mono.CSharp {
 			get { return hoisted_params; }
 		}
 
-		protected override TypeExpr [] ResolveBaseTypes (out TypeExpr base_class)
+		protected override TypeSpec[] ResolveBaseTypes (out FullNamedExpression base_class)
 		{
 			var mtype = Iterator.OriginalIteratorType;
 			if (Mutator != null)
@@ -393,6 +402,7 @@ namespace Mono.CSharp {
 		{
 			pc_field = AddCompilerGeneratedField ("$PC", new TypeExpression (Compiler.BuiltinTypes.Int, Location));
 			current_field = AddCompilerGeneratedField ("$current", iterator_type_expr);
+			disposing_field = AddCompilerGeneratedField ("$disposing", new TypeExpression (Compiler.BuiltinTypes.Bool, Location));
 
 			if (hoisted_params != null) {
 				//
@@ -686,7 +696,7 @@ namespace Mono.CSharp {
 			Label [] labels = null;
 			int n_resume_points = resume_points == null ? 0 : resume_points.Count;
 			for (int i = 0; i < n_resume_points; ++i) {
-				ResumableStatement s = (ResumableStatement) resume_points [i];
+				ResumableStatement s = resume_points [i];
 				Label ret = s.PrepareForDispose (ec, end);
 				if (ret.Equals (end) && labels == null)
 					continue;
@@ -695,6 +705,7 @@ namespace Mono.CSharp {
 					for (int j = 0; j <= i; ++j)
 						labels [j] = end;
 				}
+
 				labels [i+1] = ret;
 			}
 
@@ -705,6 +716,10 @@ namespace Mono.CSharp {
 				ec.Emit (OpCodes.Stloc, current_pc);
 			}
 
+			ec.Emit (OpCodes.Ldarg_0);
+			ec.EmitInt (1);
+			ec.Emit (OpCodes.Stfld, IteratorHost.DisposingField.Spec);
+
 			ec.Emit (OpCodes.Ldarg_0);
 			ec.EmitInt ((int) State.After);
 			ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
@@ -741,10 +756,21 @@ namespace Mono.CSharp {
 			expr.Emit (ec);
 			ec.Emit (OpCodes.Stfld, IteratorHost.CurrentField.Spec);
 
+			//
+			// Guard against being disposed meantime
+			//
+			Label disposed = ec.DefineLabel ();
+			ec.Emit (OpCodes.Ldarg_0);
+			ec.Emit (OpCodes.Ldfld, IteratorHost.DisposingField.Spec);
+			ec.Emit (OpCodes.Brtrue_S, disposed);
+
+			//
 			// store resume program-counter
+			//
 			ec.Emit (OpCodes.Ldarg_0);
 			ec.EmitInt (resume_pc);
 			ec.Emit (OpCodes.Stfld, IteratorHost.PC.Spec);
+			ec.MarkLabel (disposed);
 
 			// mark finally blocks as disabled
 			if (unwind_protect && skip_finally != null) {
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/literal.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/literal.cs
index cf48e07cc..aa6b1d4bb 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/literal.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/literal.cs
@@ -51,7 +51,7 @@ namespace Mono.CSharp {
 				return;
 			}
 
-			if (TypeManager.IsValueType (t)) {
+			if (TypeSpec.IsValueType (t)) {
 				ec.Report.Error(37, loc, "Cannot convert null to `{0}' because it is a value type",
 					TypeManager.CSharpName(t));
 				return;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/membercache.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/membercache.cs
index 9ffe5276e..a01100c25 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/membercache.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/membercache.cs
@@ -534,7 +534,7 @@ namespace Mono.CSharp {
 		// Returns base members of @member member if no exact match is found @bestCandidate returns
 		// the best match
 		//
-		public static MemberSpec FindBaseMember (MemberCore member, out MemberSpec bestCandidate)
+		public static MemberSpec FindBaseMember (MemberCore member, out MemberSpec bestCandidate, ref bool overrides)
 		{
 			bestCandidate = null;
 			var container = member.Parent.PartialContainer.Definition;
@@ -547,12 +547,14 @@ namespace Mono.CSharp {
 			}
 
 			string name = GetLookupName (member);
-			IList<MemberSpec> applicable;
 			var member_param = member is IParametersMember ? ((IParametersMember) member).Parameters : null;
 
 			var mkind = GetMemberCoreKind (member);
 			bool member_with_accessors = mkind == MemberKind.Indexer || mkind == MemberKind.Property;
 
+			IList<MemberSpec> applicable;
+			MemberSpec ambig_candidate = null;
+
 			do {
 				if (container.MemberCache.member_hash.TryGetValue (name, out applicable)) {
 					for (int i = 0; i < applicable.Count; ++i) {
@@ -598,31 +600,39 @@ namespace Mono.CSharp {
 						}
 
 						//
-						// Skip override members with accessors they may not fully implement the base member
+						// Skip override for member with accessors. It may not fully implement the base member
+						// but keep flag we found an implementation in case the base member is abstract
 						//
-						if (member_with_accessors) {
-							if ((entry.Modifiers & (Modifiers.OVERRIDE | Modifiers.SEALED)) == Modifiers.OVERRIDE) {
-								//
-								// Set candidate to member override to flag we found an implementation
-								//
-								bestCandidate = entry;
-								continue;
-							}
-						} else {
+						if (member_with_accessors && ((entry.Modifiers & (Modifiers.OVERRIDE | Modifiers.SEALED)) == Modifiers.OVERRIDE)) {
+							//
+							// Set candidate to override implementation to flag we found an implementation
+							//
+							overrides = true;
+							continue;
+						}
+
+						//
+						// For members with parameters we can encounter an ambiguous candidates (they match exactly)
+						// because generic type parameters could be inflated into same types
+						//
+						if (ambig_candidate == null && (entry.Kind & mkind & (MemberKind.Method | MemberKind.Indexer)) != 0) {
 							bestCandidate = null;
+							ambig_candidate = entry;
+							continue;
 						}
 
+						bestCandidate = ambig_candidate;
 						return entry;
 					}
 				}
 
-				if (container.IsInterface)
+				if (container.IsInterface || ambig_candidate != null)
 					break;
 
 				container = container.BaseType;
 			} while (container != null);
 
-			return null;
+			return ambig_candidate;
 		}
 
 		//
@@ -700,7 +710,7 @@ namespace Mono.CSharp {
 		//
 		// Returns members of @iface only, base members are ignored
 		//
-		public static IList<MethodSpec> GetInterfaceMethods (TypeSpec iface)
+		public static List<MethodSpec> GetInterfaceMethods (TypeSpec iface)
 		{
 			//
 			// MemberCache flatten interfaces, therefore in cases like this one
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/method.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/method.cs
index 2f8080939..75c164b90 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/method.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/method.cs
@@ -134,6 +134,15 @@ namespace Mono.CSharp {
 			get { return "M:"; }
 		}
 
+		public override void Emit ()
+		{
+			if ((ModFlags & Modifiers.COMPILER_GENERATED) == 0) {
+				parameters.CheckConstraints (this);
+			}
+
+			base.Emit ();
+		}
+
 		public override bool EnableOverloadChecks (MemberCore overload)
 		{
 			if (overload is MethodCore) {
@@ -668,11 +677,14 @@ namespace Mono.CSharp {
 				}
 			}
 
-			if (MethodData != null)
-				MethodData.Emit (Parent);
+			if (type_expr != null)
+				ConstraintChecker.Check (this, member_type, type_expr.Location);
 
 			base.Emit ();
 
+			if (MethodData != null)
+				MethodData.Emit (Parent);
+
 			Block = null;
 			MethodData = null;
 		}
@@ -704,6 +716,12 @@ namespace Mono.CSharp {
 
 		#region IMethodData Members
 
+		bool IMethodData.IsAccessor {
+			get {
+				return false;
+			}
+		}
+
 		public TypeSpec ReturnType {
 			get {
 				return MemberType;
@@ -858,23 +876,6 @@ namespace Mono.CSharp {
 			}
 		}
 
-		public override bool HasUnresolvedConstraints {
-			get {
-				if (CurrentTypeParameters == null)
-					return false;
-
-				// When overriding base method constraints are fetched from
-				// base method but to find it we have to resolve parameters
-				// to find exact base method match
-				if (IsExplicitImpl || (ModFlags & Modifiers.OVERRIDE) != 0)
-					return base_method == null;
-
-				// Even for non-override generic method constraints check has to be
-				// delayed after all constraints are resolved
-				return true;
-			}
-		}
-
 		public TypeParameterSpec[] TypeParameters {
 			get {
 				// TODO: Cache this
@@ -918,7 +919,7 @@ namespace Mono.CSharp {
 					(parameters[0].ModFlags & ~Parameter.Modifier.PARAMS) == Parameter.Modifier.NONE;
 		}
 
-		public override FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
+		public override FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 		{
 			if (arity == 0) {
 				TypeParameter[] tp = CurrentTypeParameters;
@@ -929,7 +930,7 @@ namespace Mono.CSharp {
 				}
 			}
 
-			return base.LookupNamespaceOrType (name, arity, loc, ignore_cs0104);
+			return base.LookupNamespaceOrType (name, arity, mode, loc);
 		}
 
 		public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
@@ -1107,7 +1108,7 @@ namespace Mono.CSharp {
 			if (!base.Define ())
 				return false;
 
-			if (type_expr.Type.Kind == MemberKind.Void && parameters.IsEmpty && MemberName.Arity == 0 && MemberName.Name == Destructor.MetadataName) {
+			if (member_type.Kind == MemberKind.Void && parameters.IsEmpty && MemberName.Arity == 0 && MemberName.Name == Destructor.MetadataName) {
 				Report.Warning (465, 1, Location,
 					"Introducing `Finalize' method can interfere with destructor invocation. Did you intend to declare a destructor?");
 			}
@@ -1217,19 +1218,9 @@ namespace Mono.CSharp {
 				}
 
 				if (CurrentTypeParameters != null) {
-					var ge = type_expr as GenericTypeExpr;
-					if (ge != null)
-						ge.CheckConstraints (this);
-
-					foreach (Parameter p in parameters.FixedParameters) {
-						ge = p.TypeExpression as GenericTypeExpr;
-						if (ge != null)
-							ge.CheckConstraints (this);
-					}
-
 					for (int i = 0; i < CurrentTypeParameters.Length; ++i) {
 						var tp = CurrentTypeParameters [i];
-						tp.CheckGenericConstraints ();
+						tp.CheckGenericConstraints (false);
 						tp.Emit ();
 					}
 				}
@@ -1452,7 +1443,15 @@ namespace Mono.CSharp {
 		}
 
 		public override AttributeTargets AttributeTargets {
-			get { return AttributeTargets.Constructor; }
+			get {
+				return AttributeTargets.Constructor;
+			}
+		}
+
+		bool IMethodData.IsAccessor {
+			get {
+				return false;
+			}
 		}
 
 		//
@@ -1582,6 +1581,7 @@ namespace Mono.CSharp {
 				OptAttributes.Emit ();
 
 			base.Emit ();
+			parameters.ApplyAttributes (this, ConstructorBuilder);
 
 			//
 			// If we use a "this (...)" constructor initializer, then
@@ -1613,8 +1613,6 @@ namespace Mono.CSharp {
 				}
 			}
 
-			parameters.ApplyAttributes (this, ConstructorBuilder);
-
 			SourceMethod source = SourceMethod.Create (Parent, ConstructorBuilder, block);
 
 			if (block != null) {
@@ -1647,7 +1645,7 @@ namespace Mono.CSharp {
 			block = null;
 		}
 
-		protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate)
+		protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
 		{
 			// Is never override
 			bestCandidate = null;
@@ -1736,6 +1734,7 @@ namespace Mono.CSharp {
 		GenericMethod GenericMethod { get; }
 		ParametersCompiled ParameterInfo { get; }
 		MethodSpec Spec { get; }
+		bool IsAccessor { get; }
 
 		Attributes OptAttributes { get; }
 		ToplevelBlock Block { get; set; }
@@ -1810,24 +1809,25 @@ namespace Mono.CSharp {
 			TypeContainer container = parent.PartialContainer;
 
 			PendingImplementation pending = container.PendingImplementations;
-			if (pending != null){
-				implementing = pending.IsInterfaceMethod (method.MethodName, member.InterfaceType, this);
+			MethodSpec ambig_iface_method;
+			if (pending != null) {
+				implementing = pending.IsInterfaceMethod (method.MethodName, member.InterfaceType, this, out ambig_iface_method);
 
-				if (member.InterfaceType != null){
-					if (implementing == null){
+				if (member.InterfaceType != null) {
+					if (implementing == null) {
 						if (member is PropertyBase) {
 							Report.Error (550, method.Location, "`{0}' is an accessor not found in interface member `{1}{2}'",
-								      method.GetSignatureForError (), TypeManager.CSharpName (member.InterfaceType),
-								      member.GetSignatureForError ().Substring (member.GetSignatureForError ().LastIndexOf ('.')));
+									  method.GetSignatureForError (), TypeManager.CSharpName (member.InterfaceType),
+									  member.GetSignatureForError ().Substring (member.GetSignatureForError ().LastIndexOf ('.')));
 
 						} else {
 							Report.Error (539, method.Location,
-								      "`{0}.{1}' in explicit interface declaration is not a member of interface",
-								      TypeManager.CSharpName (member.InterfaceType), member.ShortName);
+									  "`{0}.{1}' in explicit interface declaration is not a member of interface",
+									  TypeManager.CSharpName (member.InterfaceType), member.ShortName);
 						}
 						return false;
 					}
-					if (implementing.IsAccessor && !(method is AbstractPropertyEventMethod)) {
+					if (implementing.IsAccessor && !method.IsAccessor) {
 						Report.SymbolRelatedToPreviousError (implementing);
 						Report.Error (683, method.Location, "`{0}' explicit method implementation cannot implement `{1}' because it is an accessor",
 							member.GetSignatureForError (), TypeManager.CSharpSignature (implementing));
@@ -1835,8 +1835,7 @@ namespace Mono.CSharp {
 					}
 				} else {
 					if (implementing != null) {
-						AbstractPropertyEventMethod prop_method = method as AbstractPropertyEventMethod;
-						if (prop_method == null) {
+						if (!method.IsAccessor) {
 							if (implementing.IsAccessor) {
 								Report.SymbolRelatedToPreviousError (implementing);
 								Report.Error (470, method.Location, "Method `{0}' cannot implement interface accessor `{1}'",
@@ -1848,7 +1847,7 @@ namespace Mono.CSharp {
 								Report.Error (686, method.Location, "Accessor `{0}' cannot implement interface member `{1}' for type `{2}'. Use an explicit interface implementation",
 									method.GetSignatureForError (), TypeManager.CSharpSignature (implementing), container.GetSignatureForError ());
 							} else {
-								PropertyBase.PropertyMethod pm = prop_method as PropertyBase.PropertyMethod;
+								PropertyBase.PropertyMethod pm = method as PropertyBase.PropertyMethod;
 								if (pm != null && pm.HasCustomAccessModifier && (pm.ModFlags & Modifiers.PUBLIC) == 0) {
 									Report.SymbolRelatedToPreviousError (implementing);
 									Report.Error (277, method.Location, "Accessor `{0}' must be declared public to implement interface member `{1}'",
@@ -1858,6 +1857,8 @@ namespace Mono.CSharp {
 						}
 					}
 				}
+			} else {
+				ambig_iface_method = null;
 			}
 
 			//
@@ -1878,6 +1879,15 @@ namespace Mono.CSharp {
 						Report.Error (466, method.Location, "`{0}': the explicit interface implementation cannot introduce the params modifier",
 							method.GetSignatureForError ());
 					}
+
+					if (ambig_iface_method != null) {
+						Report.SymbolRelatedToPreviousError (ambig_iface_method);
+						Report.SymbolRelatedToPreviousError (implementing);
+						Report.Warning (473, 2, method.Location,
+							"Explicit interface implementation `{0}' matches more than one interface member. Consider using a non-explicit implementation instead",
+							method.GetSignatureForError ());
+					}
+
 				} else {
 					if (implementing.DeclaringType.IsInterface) {
 						//
@@ -1931,7 +1941,7 @@ namespace Mono.CSharp {
 				// clear the pending implementation flag (requires explicit methods to be defined first)
 				//
 				parent.PartialContainer.PendingImplementations.ImplementMethod (method.MethodName,
-					member.InterfaceType, this, member.IsExplicitImpl);
+					member.InterfaceType, this, member.IsExplicitImpl, out ambig_iface_method);
 
 				//
 				// Update indexer accessor name to match implementing abstract accessor
@@ -2165,6 +2175,12 @@ namespace Mono.CSharp {
 			return new EmitContext (this, ig, ReturnType);
 		}
 
+		public bool IsAccessor {
+			get {
+				return true;
+			}
+		}
+
 		public bool IsExcluded ()
 		{
 			return false;
@@ -2563,7 +2579,7 @@ namespace Mono.CSharp {
 			return true;
 		}
 
-		protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate)
+		protected override MemberSpec FindBaseMember (out MemberSpec bestCandidate, ref bool overrides)
 		{
 			// Operator cannot be override
 			bestCandidate = null;
@@ -2647,7 +2663,8 @@ namespace Mono.CSharp {
 			StringBuilder sb = new StringBuilder ();
 			if (OperatorType == OpType.Implicit || OperatorType == OpType.Explicit) {
 				sb.AppendFormat ("{0}.{1} operator {2}",
-					Parent.GetSignatureForError (), GetName (OperatorType), type_expr.GetSignatureForError ());
+					Parent.GetSignatureForError (), GetName (OperatorType),
+					member_type == null ? type_expr.GetSignatureForError () : member_type.GetSignatureForError ());
 			}
 			else {
 				sb.AppendFormat ("{0}.operator {1}", Parent.GetSignatureForError (), GetName (OperatorType));
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/namespace.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/namespace.cs
index a19f5938a..fdafbee39 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/namespace.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/namespace.cs
@@ -63,13 +63,6 @@ namespace Mono.CSharp {
 			: base ("global")
 		{
 		}
-
-		public override void Error_NamespaceDoesNotExist (Location loc, string name, int arity, IMemberContext ctx)
-		{
-			ctx.Module.Compiler.Report.Error (400, loc,
-				"The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
-				name);
-		}
 	}
 
 	//
@@ -159,9 +152,16 @@ namespace Mono.CSharp {
 			return this;
 		}
 
-		public virtual void Error_NamespaceDoesNotExist (Location loc, string name, int arity, IMemberContext ctx)
+		public void Error_NamespaceDoesNotExist (IMemberContext ctx, string name, int arity, Location loc)
 		{
-			var retval = LookupType (ctx, name, -System.Math.Max (1, arity), loc);
+			var retval = LookupType (ctx, name, arity, LookupMode.IgnoreAccessibility, loc);
+			if (retval != null) {
+				ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (retval.Type);
+				ErrorIsInaccesible (ctx, retval.GetSignatureForError (), loc);
+				return;
+			}
+
+			retval = LookupType (ctx, name, -System.Math.Max (1, arity), LookupMode.Probing, loc);
 			if (retval != null) {
 				Error_TypeArgumentsCannotBeUsed (ctx, retval.Type, arity, loc);
 				return;
@@ -173,9 +173,15 @@ namespace Mono.CSharp {
 				return;
 			}
 
-			ctx.Module.Compiler.Report.Error (234, loc,
-				"The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
-				name, GetSignatureForError ());
+			if (this is GlobalRootNamespace) {
+				ctx.Module.Compiler.Report.Error (400, loc,
+					"The type or namespace name `{0}' could not be found in the global namespace (are you missing an assembly reference?)",
+					name);
+			} else {
+				ctx.Module.Compiler.Report.Error (234, loc,
+					"The type or namespace name `{0}' does not exist in the namespace `{1}'. Are you missing an assembly reference?",
+					name, GetSignatureForError ());
+			}
 		}
 
 		public override string GetSignatureForError ()
@@ -217,7 +223,7 @@ namespace Mono.CSharp {
 			return found;
 		}
 
-		public TypeExpr LookupType (IMemberContext ctx, string name, int arity, Location loc)
+		public TypeExpr LookupType (IMemberContext ctx, string name, int arity, LookupMode mode, Location loc)
 		{
 			if (types == null)
 				return null;
@@ -234,14 +240,19 @@ namespace Mono.CSharp {
 			foreach (var ts in found) {
 				if (ts.Arity == arity) {
 					if (best == null) {
+						if ((ts.Modifiers & Modifiers.INTERNAL) != 0 && !ts.MemberDefinition.IsInternalAsPublic (ctx.Module.DeclaringAssembly) && mode != LookupMode.IgnoreAccessibility)
+							continue;
+
 						best = ts;
 						continue;
 					}
 
 					if (best.MemberDefinition.IsImported && ts.MemberDefinition.IsImported) {
-						ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (best);
-						ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (ts);
-						ctx.Module.Compiler.Report.Error (433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError ());
+						if (mode == LookupMode.Normal) {
+							ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (best);
+							ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (ts);
+							ctx.Module.Compiler.Report.Error (433, loc, "The imported type `{0}' is defined multiple times", ts.GetSignatureForError ());
+						}
 						break;
 					}
 
@@ -251,6 +262,9 @@ namespace Mono.CSharp {
 					if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !best.MemberDefinition.IsInternalAsPublic (ctx.Module.DeclaringAssembly))
 						continue;
 
+					if (mode != LookupMode.Normal)
+						continue;
+
 					if (ts.MemberDefinition.IsImported)
 						ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (ts);
 
@@ -260,7 +274,7 @@ namespace Mono.CSharp {
 				}
 
 				//
-				// Lookup for the best candidate with closest arity match
+				// Lookup for the best candidate with the closest arity match
 				//
 				if (arity < 0) {
 					if (best == null) {
@@ -274,13 +288,10 @@ namespace Mono.CSharp {
 			if (best == null)
 				return null;
 
-			if ((best.Modifiers & Modifiers.INTERNAL) != 0 && !best.MemberDefinition.IsInternalAsPublic (ctx.Module.DeclaringAssembly))
-				return null;
-
 			te = new TypeExpression (best, Location.Null);
 
 			// TODO MemberCache: Cache more
-			if (arity == 0)
+			if (arity == 0 && mode == LookupMode.Normal)
 				cached_types.Add (name, te);
 
 			return te;
@@ -317,20 +328,22 @@ namespace Mono.CSharp {
 			return null;
 		}
 
-		public FullNamedExpression LookupTypeOrNamespace (IMemberContext ctx, string name, int arity, Location loc)
+		public FullNamedExpression LookupTypeOrNamespace (IMemberContext ctx, string name, int arity, LookupMode mode, Location loc)
 		{
-			var texpr = LookupType (ctx, name, arity, loc);
+			var texpr = LookupType (ctx, name, arity, mode, loc);
 
 			Namespace ns;
 			if (arity == 0 && namespaces.TryGetValue (name, out ns)) {
 				if (texpr == null)
 					return ns;
 
-				ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (texpr.Type);
-				// ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (ns.loc, "");
-				ctx.Module.Compiler.Report.Warning (437, 2, loc,
-					"The type `{0}' conflicts with the imported namespace `{1}'. Using the definition found in the source file",
-					texpr.GetSignatureForError (), ns.GetSignatureForError ());
+				if (mode != LookupMode.Probing) {
+					ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (texpr.Type);
+					// ctx.Module.Compiler.Report.SymbolRelatedToPreviousError (ns.loc, "");
+					ctx.Module.Compiler.Report.Warning (437, 2, loc,
+						"The type `{0}' conflicts with the imported namespace `{1}'. Using the definition found in the source file",
+						texpr.GetSignatureForError (), ns.GetSignatureForError ());
+				}
 
 				if (texpr.Type.MemberDefinition.IsImported)
 					return ns;
@@ -823,12 +836,12 @@ namespace Mono.CSharp {
 			return parent.LookupExtensionMethod (extensionType, name, arity, ref scope);
 		}
 
-		public FullNamedExpression LookupNamespaceOrType (string name, int arity, Location loc, bool ignore_cs0104)
+		public FullNamedExpression LookupNamespaceOrType (string name, int arity, LookupMode mode, Location loc)
 		{
 			// Precondition: Only simple names (no dots) will be looked up with this function.
 			FullNamedExpression resolved = null;
 			for (NamespaceContainer curr_ns = this; curr_ns != null; curr_ns = curr_ns.ImplicitParent) {
-				if ((resolved = curr_ns.Lookup (name, arity, loc, ignore_cs0104)) != null)
+				if ((resolved = curr_ns.Lookup (name, arity, mode, loc)) != null)
 					break;
 			}
 
@@ -872,12 +885,12 @@ namespace Mono.CSharp {
 			return null;
 		}
 
-		private FullNamedExpression Lookup (string name, int arity, Location loc, bool ignore_cs0104)
+		FullNamedExpression Lookup (string name, int arity, LookupMode mode, Location loc)
 		{
 			//
 			// Check whether it's in the namespace.
 			//
-			FullNamedExpression fne = ns.LookupTypeOrNamespace (this, name, arity, loc);
+			FullNamedExpression fne = ns.LookupTypeOrNamespace (this, name, arity, mode, loc);
 
 			//
 			// Check aliases. 
@@ -887,12 +900,14 @@ namespace Mono.CSharp {
 					if (ue.Alias == name) {
 						if (fne != null) {
 							if (Doppelganger != null) {
-								// TODO: Namespace has broken location
-								//Report.SymbolRelatedToPreviousError (fne.Location, null);
-								Compiler.Report.SymbolRelatedToPreviousError (ue.Location, null);
-								Compiler.Report.Error (576, loc,
-									"Namespace `{0}' contains a definition with same name as alias `{1}'",
-									GetSignatureForError (), name);
+								if (mode == LookupMode.Normal) {
+									// TODO: Namespace has broken location
+									//Report.SymbolRelatedToPreviousError (fne.Location, null);
+									Compiler.Report.SymbolRelatedToPreviousError (ue.Location, null);
+									Compiler.Report.Error (576, loc,
+										"Namespace `{0}' contains a definition with same name as alias `{1}'",
+										GetSignatureForError (), name);
+								}
 							} else {
 								return fne;
 							}
@@ -903,10 +918,8 @@ namespace Mono.CSharp {
 				}
 			}
 
-			if (fne != null) {
-				if (!((fne.Type.Modifiers & Modifiers.INTERNAL) != 0 && !fne.Type.MemberDefinition.IsInternalAsPublic (module.DeclaringAssembly)))
-					return fne;
-			}
+			if (fne != null)
+				return fne;
 
 			if (IsImplicit)
 				return null;
@@ -918,7 +931,7 @@ namespace Mono.CSharp {
 			foreach (Namespace using_ns in GetUsingTable ()) {
 				// A using directive imports only types contained in the namespace, it
 				// does not import any nested namespaces
-				fne = using_ns.LookupType (this, name, arity, loc);
+				fne = using_ns.LookupType (this, name, arity, mode, loc);
 				if (fne == null)
 					continue;
 
@@ -937,16 +950,16 @@ namespace Mono.CSharp {
 					continue;
 				}
 
-				if (ignore_cs0104)
-					return match;
-
 				// It can be top level accessibility only
 				var better = Namespace.IsImportedTypeOverride (module, texpr_match.Type, texpr_fne.Type);
 				if (better == null) {
-					Compiler.Report.SymbolRelatedToPreviousError (texpr_match.Type);
-					Compiler.Report.SymbolRelatedToPreviousError (texpr_fne.Type);
-					Compiler.Report.Error (104, loc, "`{0}' is an ambiguous reference between `{1}' and `{2}'",
-						name, texpr_match.GetSignatureForError (), texpr_fne.GetSignatureForError ());
+					if (mode == LookupMode.Normal) {
+						Compiler.Report.SymbolRelatedToPreviousError (texpr_match.Type);
+						Compiler.Report.SymbolRelatedToPreviousError (texpr_fne.Type);
+						Compiler.Report.Error (104, loc, "`{0}' is an ambiguous reference between `{1}' and `{2}'",
+							name, texpr_match.GetSignatureForError (), texpr_fne.GetSignatureForError ());
+					}
+
 					return match;
 				}
 
@@ -1090,11 +1103,6 @@ namespace Mono.CSharp {
 			get { return SlaveDeclSpace.CurrentTypeParameters; }
 		}
 
-		// FIXME: It's false for expression types
-		public bool HasUnresolvedConstraints {
-			get { return true; }
-		}
-
 		public bool IsObsolete {
 			get { return SlaveDeclSpace.IsObsolete; }
 		}
@@ -1213,9 +1221,6 @@ namespace Mono.CSharp {
 				return null;
 			}
 
-			if (resolved is TypeExpr)
-				resolved = resolved.ResolveAsType (rc);
-
 			return resolved;
 		}
 	}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/nullable.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/nullable.cs
index f5e215570..f6b9abcca 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/nullable.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/nullable.cs
@@ -23,29 +23,27 @@ namespace Mono.CSharp.Nullable
 {
 	public class NullableType : TypeExpr
 	{
-		TypeExpr underlying;
+		readonly TypeSpec underlying;
 
-		public NullableType (TypeExpr underlying, Location l)
+		public NullableType (TypeSpec type, Location loc)
 		{
-			this.underlying = underlying;
-			loc = l;
-
-			eclass = ExprClass.Type;
+			this.underlying = type;
+			this.loc = loc;
 		}
 
-		public NullableType (TypeSpec type, Location loc)
-			: this (new TypeExpression (type, loc), loc)
-		{ }
-
-		public override TypeExpr ResolveAsType (IMemberContext ec)
+		public override TypeSpec ResolveAsType (IMemberContext ec)
 		{
-			var type = ec.Module.PredefinedTypes.Nullable.Resolve ();
-			if (type == null)
+			eclass = ExprClass.Type;
+
+			var otype = ec.Module.PredefinedTypes.Nullable.Resolve ();
+			if (otype == null)
 				return null;
 
-			TypeArguments args = new TypeArguments (underlying);
-			GenericTypeExpr ctype = new GenericTypeExpr (type, args, loc);
-			return ctype.ResolveAsType (ec);
+			TypeArguments args = new TypeArguments (new TypeExpression (underlying, loc));
+			GenericTypeExpr ctype = new GenericTypeExpr (otype, args, loc);
+			
+			type = ctype.ResolveAsType (ec);
+			return type;
 		}
 	}
 
@@ -415,7 +413,7 @@ namespace Mono.CSharp.Nullable
 					return null;
 
 				null_value = LiftedNull.Create (type, loc);
-			} else if (TypeManager.IsValueType (type)) {
+			} else if (TypeSpec.IsValueType (type)) {
 				null_value = LiftedNull.Create (type, loc);
 			} else {
 				null_value = new NullConstant (type, loc);
@@ -521,9 +519,8 @@ namespace Mono.CSharp.Nullable
 
 		Expression LiftExpression (ResolveContext ec, Expression expr)
 		{
-			TypeExpr lifted_type = new NullableType (expr.Type, expr.Location);
-			lifted_type = lifted_type.ResolveAsType (ec);
-			if (lifted_type == null)
+			var lifted_type = new NullableType (expr.Type, expr.Location);
+			if (lifted_type.ResolveAsType (ec) == null)
 				return null;
 
 			expr.Type = lifted_type.Type;
@@ -865,26 +862,24 @@ namespace Mono.CSharp.Nullable
 
 		Expression LiftResult (ResolveContext ec, Expression res_expr)
 		{
-			TypeExpr lifted_type;
+			TypeSpec lifted_type;
 
 			//
 			// Avoid double conversion
 			//
 			if (left_unwrap == null || IsLeftNullLifted || left_unwrap.Type != left.Type || (left_unwrap != null && IsRightNullLifted)) {
-				lifted_type = new NullableType (left.Type, loc);
-				lifted_type = lifted_type.ResolveAsType (ec);
+				lifted_type = new NullableType (left.Type, loc).ResolveAsType (ec);
 				if (lifted_type == null)
 					return null;
 
 				if (left is UserCast || left is TypeCast)
-					left.Type = lifted_type.Type;
+					left.Type = lifted_type;
 				else
-					left = EmptyCast.Create (left, lifted_type.Type);
+					left = EmptyCast.Create (left, lifted_type);
 			}
 
 			if (left != right && (right_unwrap == null || IsRightNullLifted || right_unwrap.Type != right.Type || (right_unwrap != null && IsLeftNullLifted))) {
-				lifted_type = new NullableType (right.Type, loc);
-				lifted_type = lifted_type.ResolveAsType (ec);
+				lifted_type = new NullableType (right.Type, loc).ResolveAsType (ec);
 				if (lifted_type == null)
 					return null;
 
@@ -893,19 +888,18 @@ namespace Mono.CSharp.Nullable
 					r = ((ReducedExpression) r).OriginalExpression;
 
 				if (r is UserCast || r is TypeCast)
-					r.Type = lifted_type.Type;
+					r.Type = lifted_type;
 				else
-					right = EmptyCast.Create (right, lifted_type.Type);
+					right = EmptyCast.Create (right, lifted_type);
 			}
 
 			if ((Oper & Operator.ComparisonMask) == 0) {
-				lifted_type = new NullableType (res_expr.Type, loc);
-				lifted_type = lifted_type.ResolveAsType (ec);
+				lifted_type = new NullableType (res_expr.Type, loc).ResolveAsType (ec);
 				if (lifted_type == null)
 					return null;
 
-				wrap_ctor = NullableInfo.GetConstructor (lifted_type.Type);
-				type = res_expr.Type = lifted_type.Type;
+				wrap_ctor = NullableInfo.GetConstructor (lifted_type);
+				type = res_expr.Type = lifted_type;
 			}
 
 			if (IsLeftNullLifted) {
@@ -998,7 +992,7 @@ namespace Mono.CSharp.Nullable
 			// Lift the result in the case it can be null and predefined or user operator
 			// result type is of a value type
 			//
-			if (!TypeManager.IsValueType (expr.Type))
+			if (!TypeSpec.IsValueType (expr.Type))
 				return null;
 
 			if (state != orig_state)
@@ -1101,7 +1095,7 @@ namespace Mono.CSharp.Nullable
 					type = ltype;
 					return this;
 				}
-			} else if (TypeManager.IsReferenceType (ltype)) {
+			} else if (TypeSpec.IsReferenceType (ltype)) {
 				if (Convert.ImplicitConversionExists (ec, right, ltype)) {
 					//
 					// If right is a dynamic expression, the result type is dynamic
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/parameter.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/parameter.cs
index 40ea21707..8a23be9ff 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/parameter.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/parameter.cs
@@ -357,13 +357,11 @@ namespace Mono.CSharp {
 			if (attributes != null)
 				attributes.AttachTo (this, rc);
 
-			var expr = texpr.ResolveAsType (rc);
-			if (expr == null)
+			parameter_type = texpr.ResolveAsType (rc);
+			if (parameter_type == null)
 				return null;
 
 			this.idx = index;
-			texpr = expr;
-			parameter_type = texpr.Type;
 	
 			if ((modFlags & Parameter.Modifier.ISBYREF) != 0 && parameter_type.IsSpecialRuntimeType) {
 				rc.Module.Compiler.Report.Error (1601, Location, "Method or delegate parameter cannot be of type `{0}'",
@@ -435,7 +433,7 @@ namespace Mono.CSharp {
 				}
 
 				if (TypeSpecComparer.IsEqual (default_expr.Type, parameter_type) ||
-					(default_expr is NullConstant && TypeManager.IsReferenceType (parameter_type) && !parameter_type.IsGenericParameter) ||
+					(default_expr is NullConstant && TypeSpec.IsReferenceType (parameter_type) && !parameter_type.IsGenericParameter) ||
 					parameter_type.BuiltinType == BuiltinTypeSpec.Type.Object) {
 					return;
 				}
@@ -605,8 +603,7 @@ namespace Mono.CSharp {
 			expr_tree_variable = (TemporaryVariableReference) expr_tree_variable.Resolve (ec);
 
 			Arguments arguments = new Arguments (2);
-			arguments.Add (new Argument (new TypeOf (
-				new TypeExpression (parameter_type, Location), Location)));
+			arguments.Add (new Argument (new TypeOf (parameter_type, Location)));
 			arguments.Add (new Argument (new StringConstant (ec.BuiltinTypes, Name, Location)));
 			return new SimpleAssign (ExpressionTreeVariableReference (),
 				Expression.CreateExpressionFactoryCall (ec, "Parameter", null, arguments, Location));
@@ -1013,6 +1010,17 @@ namespace Mono.CSharp {
 				null);
 		}
 
+		public void CheckConstraints (IMemberContext mc)
+		{
+			foreach (Parameter p in parameters) {
+				//
+				// It's null for compiler generated types or special types like __arglist
+				//
+				if (p.TypeExpression != null)
+					ConstraintChecker.Check (mc, p.Type, p.TypeExpression.Location);
+			}
+		}
+
 		//
 		// Returns non-zero value for equal CLS parameter signatures
 		//
@@ -1254,7 +1262,7 @@ namespace Mono.CSharp {
 					}
 				}
 
-				if (!expr.IsNull && TypeManager.IsReferenceType (parameter_type) && parameter_type.BuiltinType != BuiltinTypeSpec.Type.String) {
+				if (!expr.IsNull && TypeSpec.IsReferenceType (parameter_type) && parameter_type.BuiltinType != BuiltinTypeSpec.Type.String) {
 					rc.Report.Error (1763, Location,
 						"Optional parameter `{0}' of type `{1}' can only be initialized with `null'",
 						p.Name, parameter_type.GetSignatureForError ());
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/pending.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/pending.cs
index 3800f2921..696797aa0 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/pending.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/pending.cs
@@ -11,6 +11,7 @@
 // Copyright 2003-2008 Novell, Inc.
 //
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -55,7 +56,7 @@ namespace Mono.CSharp {
 		/// <summary>
 		///   The container for this PendingImplementation
 		/// </summary>
-		TypeContainer container;
+		readonly TypeContainer container;
 		
 		/// <summary>
 		///   This is the array of TypeAndMethods that describes the pending implementations
@@ -96,6 +97,12 @@ namespace Mono.CSharp {
 			}
 		}
 
+		Report Report {
+			get {
+				return container.Module.Compiler.Report;
+			}
+		}
+
 		struct MissingInterfacesInfo {
 			public TypeSpec Type;
 			public bool Optional;
@@ -185,7 +192,74 @@ namespace Mono.CSharp {
 			if (total == 0)
 				return null;
 
-			return new PendingImplementation (container, missing_interfaces, abstract_methods, total);
+			var pending = new PendingImplementation (container, missing_interfaces, abstract_methods, total);
+
+			//
+			// check for inherited conflicting methods
+			//
+			foreach (var p in pending.pending_implementations) {
+				//
+				// It can happen for generic interfaces only
+				//
+				if (!p.type.IsGeneric)
+					continue;
+
+				//
+				// CLR does not distinguishes between ref and out
+				//
+				for (int i = 0; i < p.methods.Count; ++i) {
+					MethodSpec compared_method = p.methods[i];
+					if (compared_method.Parameters.IsEmpty)
+						continue;
+
+					for (int ii = i + 1; ii < p.methods.Count; ++ii) {
+						MethodSpec tested_method = p.methods[ii];
+						if (compared_method.Name != tested_method.Name)
+							continue;
+
+						if (p.type != tested_method.DeclaringType)
+							continue;
+
+						if (!TypeSpecComparer.Override.IsSame (compared_method.Parameters.Types, tested_method.Parameters.Types))
+							continue;
+
+						bool exact_match = true;
+						bool ref_only_difference = false;
+						var cp = compared_method.Parameters.FixedParameters;
+						var tp = tested_method.Parameters.FixedParameters;
+
+						for (int pi = 0; pi < cp.Length; ++pi) {
+							//
+							// First check exact modifiers match
+							//
+							const Parameter.Modifier ref_out = Parameter.Modifier.REF | Parameter.Modifier.OUT;
+							if ((cp[pi].ModFlags & ref_out) == (tp[pi].ModFlags & ref_out))
+								continue;
+
+							if ((cp[pi].ModFlags & tp[pi].ModFlags & Parameter.Modifier.ISBYREF) != 0) {
+								ref_only_difference = true;
+								continue;
+							}
+
+							exact_match = false;
+							break;
+						}
+
+						if (!exact_match || !ref_only_difference)
+							continue;
+
+						pending.Report.SymbolRelatedToPreviousError (compared_method);
+						pending.Report.SymbolRelatedToPreviousError (tested_method);
+						pending.Report.Error (767, container.Location,
+							"Cannot implement interface `{0}' with the specified type parameters because it causes method `{1}' to differ on parameter modifiers only",
+							p.type.GetDefinition().GetSignatureForError (), compared_method.GetSignatureForError ());
+
+						break;
+					}
+				}
+			}
+
+			return pending;
 		}
 
 		public enum Operation {
@@ -199,14 +273,14 @@ namespace Mono.CSharp {
 		/// <summary>
 		///   Whether the specified method is an interface method implementation
 		/// </summary>
-		public MethodSpec IsInterfaceMethod (MemberName name, TypeSpec ifaceType, MethodData method)
+		public MethodSpec IsInterfaceMethod (MemberName name, TypeSpec ifaceType, MethodData method, out MethodSpec ambiguousCandidate)
 		{
-			return InterfaceMethod (name, ifaceType, method, Operation.Lookup);
+			return InterfaceMethod (name, ifaceType, method, Operation.Lookup, out ambiguousCandidate);
 		}
 
-		public void ImplementMethod (MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one) 
+		public void ImplementMethod (MemberName name, TypeSpec ifaceType, MethodData method, bool clear_one, out MethodSpec ambiguousCandidate)
 		{
-			InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll);
+			InterfaceMethod (name, ifaceType, method, clear_one ? Operation.ClearOne : Operation.ClearAll, out ambiguousCandidate);
 		}
 
 		/// <remarks>
@@ -226,21 +300,23 @@ namespace Mono.CSharp {
 		///   that was used in the interface, then we always need to create a proxy for it.
 		///
 		/// </remarks>
-		public MethodSpec InterfaceMethod (MemberName name, TypeSpec iType, MethodData method, Operation op)
+		public MethodSpec InterfaceMethod (MemberName name, TypeSpec iType, MethodData method, Operation op, out MethodSpec ambiguousCandidate)
 		{
+			ambiguousCandidate = null;
+
 			if (pending_implementations == null)
 				return null;
 
 			TypeSpec ret_type = method.method.ReturnType;
 			ParametersCompiled args = method.method.ParameterInfo;
 			bool is_indexer = method.method is Indexer.SetIndexerMethod || method.method is Indexer.GetIndexerMethod;
+			MethodSpec m;
 
 			foreach (TypeAndMethods tm in pending_implementations){
 				if (!(iType == null || tm.type == iType))
 					continue;
 
 				int method_count = tm.methods.Count;
-				MethodSpec m;
 				for (int i = 0; i < method_count; i++){
 					m = tm.methods [i];
 
@@ -275,6 +351,9 @@ namespace Mono.CSharp {
 					// for an interface indexer).
 					//
 					if (op != Operation.Lookup) {
+						if (m.IsAccessor != method.method.IsAccessor)
+							continue;
+
 						// If `t != null', then this is an explicitly interface
 						// implementation and we can always clear the method.
 						// `need_proxy' is not null if we're implementing an
@@ -290,6 +369,11 @@ namespace Mono.CSharp {
 						tm.found [i] = method;
 					}
 
+					if (op == Operation.Lookup && name.Left != null && ambiguousCandidate == null) {
+						ambiguousCandidate = m;
+						continue;
+					}
+
 					//
 					// Lookups and ClearOne return
 					//
@@ -299,9 +383,12 @@ namespace Mono.CSharp {
 
 				// If a specific type was requested, we can stop now.
 				if (tm.type == iType)
-					return null;
+					break;
 			}
-			return null;
+
+			m = ambiguousCandidate;
+			ambiguousCandidate = null;
+			return m;
 		}
 
 		/// <summary>
@@ -365,24 +452,97 @@ namespace Mono.CSharp {
 		/// </summary>
 		bool BaseImplements (TypeSpec iface_type, MethodSpec mi, out MethodSpec base_method)
 		{
+			base_method = null;
 			var base_type = container.BaseType;
 
 			//
 			// Setup filter with no return type to give better error message
 			// about mismatch at return type when the check bellow rejects them
 			//
-			var filter = new MemberFilter (mi.Name, mi.Arity, MemberKind.Method, mi.Parameters, null);
+			var parameters = mi.Parameters;
+			while (true) {
+				var candidates = MemberCache.FindMembers (base_type, mi.Name, false);
+				if (candidates == null)
+					return false;
+
+				MethodSpec similar_candidate = null;
+				foreach (var candidate in candidates) {
+					if (candidate.Kind != MemberKind.Method)
+						continue;
+
+					if (candidate.Arity != mi.Arity)
+						continue;
+
+					var candidate_param = ((MethodSpec) candidate).Parameters;
+					if (!TypeSpecComparer.Override.IsSame (parameters.Types, candidate_param.Types))
+						continue;
 
-			base_method = (MethodSpec) MemberCache.FindMember (base_type, filter, BindingRestriction.None);
+					bool modifiers_match = true;
+					for (int i = 0; i < parameters.Count; ++i) {
+						//
+						// First check exact ref/out match
+						//
+						const Parameter.Modifier ref_out = Parameter.Modifier.REF | Parameter.Modifier.OUT;
+						if ((parameters.FixedParameters[i].ModFlags & ref_out) == (candidate_param.FixedParameters[i].ModFlags & ref_out))
+							continue;
+
+						modifiers_match = false;
+
+						//
+						// Different in ref/out only
+						//
+						if ((parameters.FixedParameters[i].ModFlags & candidate_param.FixedParameters[i].ModFlags & Parameter.Modifier.ISBYREF) != 0) {
+							if (similar_candidate == null) {
+								if (!candidate.IsPublic)
+									break;
+
+								if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, ((MethodSpec) candidate).ReturnType))
+									break;
 
-			if (base_method == null || (base_method.Modifiers & Modifiers.PUBLIC) == 0)
-				return false;
+								// It's used for ref/out ambiguity overload check
+								similar_candidate = (MethodSpec) candidate;
+							}
 
-			if (base_method.DeclaringType.IsInterface)
-				return false;
+							continue;
+						}
 
-			if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, base_method.ReturnType))
-				return false;
+						similar_candidate = null;
+						break;
+					}
+
+					if (!modifiers_match)
+						continue;
+
+					//
+					// From this point on the candidate is used for detailed error reporting
+					// because it's very close match to what we are looking for
+					//
+					base_method = (MethodSpec) candidate;
+
+					if (!candidate.IsPublic)
+						return false;
+
+					if (!TypeSpecComparer.Override.IsEqual (mi.ReturnType, base_method.ReturnType))
+						return false;
+				}
+
+				if (base_method != null) {
+					if (similar_candidate != null) {
+						Report.SymbolRelatedToPreviousError (similar_candidate);
+						Report.SymbolRelatedToPreviousError (mi);
+						Report.SymbolRelatedToPreviousError (container);
+						Report.Warning (1956, 1, ((MemberCore) base_method.MemberDefinition).Location,
+							"The interface method `{0}' implementation is ambiguous between following methods: `{1}' and `{2}' in type `{3}'",
+							mi.GetSignatureForError (), base_method.GetSignatureForError (), similar_candidate.GetSignatureForError (), container.GetSignatureForError ());
+					}
+
+					break;
+				}
+
+				base_type = candidates[0].DeclaringType.BaseType;
+				if (base_type == null)
+					return false;
+			}
 
 			if (!base_method.IsVirtual) {
 #if STATIC
@@ -406,7 +566,7 @@ namespace Mono.CSharp {
 		///   Verifies that any pending abstract methods or interface methods
 		///   were implemented.
 		/// </summary>
-		public bool VerifyPendingMethods (Report Report)
+		public bool VerifyPendingMethods ()
 		{
 			int top = pending_implementations.Length;
 			bool errors = false;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/property.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/property.cs
index 588f5b07a..f27cee787 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/property.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/property.cs
@@ -306,7 +306,7 @@ namespace Mono.CSharp
 
 		public abstract class PropertyMethod : AbstractPropertyEventMethod
 		{
-			public const Modifiers AllowedModifiers =
+			const Modifiers AllowedModifiers =
 				Modifiers.PUBLIC |
 				Modifiers.PROTECTED |
 				Modifiers.INTERNAL |
@@ -319,7 +319,8 @@ namespace Mono.CSharp
 				: base (method, prefix, attrs, loc)
 			{
 				this.method = method;
-				this.ModFlags = modifiers | (method.ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE));
+				this.ModFlags = ModifiersExtensions.Check (AllowedModifiers, modifiers, 0, loc, Report);
+				this.ModFlags |= (method.ModFlags & (Modifiers.STATIC | Modifiers.UNSAFE));
 			}
 
 			public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
@@ -356,8 +357,7 @@ namespace Mono.CSharp
 					if (container.Kind == MemberKind.Interface)
 						Report.Error (275, Location, "`{0}': accessibility modifiers may not be used on accessors in an interface",
 							GetSignatureForError ());
-
-					if ((method.ModFlags & Modifiers.ABSTRACT) != 0 && (ModFlags & Modifiers.PRIVATE) != 0) {
+					else if ((method.ModFlags & Modifiers.ABSTRACT) != 0 && (ModFlags & Modifiers.PRIVATE) != 0) {
 						Report.Error (442, Location, "`{0}': abstract properties cannot have private accessors", GetSignatureForError ());
 					}
 
@@ -668,6 +668,8 @@ namespace Mono.CSharp
 				Module.PredefinedAttributes.Dynamic.EmitAttribute (PropertyBuilder, member_type, Location);
 			}
 
+			ConstraintChecker.Check (this, member_type, type_expr.Location);
+
 			first.Emit (Parent);
 			if (AccessorSecond != null)
 				AccessorSecond.Emit (Parent);
@@ -1322,6 +1324,8 @@ namespace Mono.CSharp
 				OptAttributes.Emit ();
 			}
 
+			ConstraintChecker.Check (this, member_type, type_expr.Location);
+
 			Add.Emit (Parent);
 			Remove.Emit (Parent);
 
@@ -1491,6 +1495,22 @@ namespace Mono.CSharp
 			this.parameters = parameters;
 		}
 
+		#region Properties
+
+		AParametersCollection IParametersMember.Parameters {
+			get {
+				return parameters;
+			}
+		}
+
+		public ParametersCompiled ParameterInfo {
+			get {
+				return parameters;
+			}
+		}
+
+		#endregion
+
 		public override void ApplyAttributeBuilder (Attribute a, MethodSpec ctor, byte[] cdata, PredefinedAttributes pa)
 		{
 			if (a.Type == pa.IndexerName) {
@@ -1574,6 +1594,13 @@ namespace Mono.CSharp
 			return base.EnableOverloadChecks (overload);
 		}
 
+		public override void Emit ()
+		{
+			parameters.CheckConstraints (this);
+
+			base.Emit ();
+		}
+
 		public override string GetSignatureForError ()
 		{
 			StringBuilder sb = new StringBuilder (Parent.GetSignatureForError ());
@@ -1592,18 +1619,6 @@ namespace Mono.CSharp
 			return base.GetSignatureForDocumentation () + parameters.GetSignatureForDocumentation ();
 		}
 
-		public AParametersCollection Parameters {
-			get {
-				return parameters;
-			}
-		}
-
-		public ParametersCompiled ParameterInfo {
-			get {
-				return parameters;
-			}
-		}
-
 		protected override bool VerifyClsCompliance ()
 		{
 			if (!base.VerifyClsCompliance ())
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/reflection.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/reflection.cs
index d5b7d1753..6f2f183a8 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/reflection.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/reflection.cs
@@ -69,13 +69,6 @@ namespace Mono.CSharp
 			return MemberKind.Class;
 		}
 
-		public override void GetCustomAttributeTypeName (CustomAttributeData cad, out string typeNamespace, out string typeName)
-		{
-			var dt = cad.Constructor.DeclaringType;
-			typeNamespace = dt.Namespace;
-			typeName = dt.Name;
-		}
-
 		protected override bool HasVolatileModifier (Type[] modifiers)
 		{
 			foreach (var t in modifiers) {
@@ -110,7 +103,7 @@ namespace Mono.CSharp
 
 		public ImportedModuleDefinition ImportModule (Module module, RootNamespace targetNamespace)
 		{
-			var module_definition = new ImportedModuleDefinition (module, this);
+			var module_definition = new ImportedModuleDefinition (module);
 			module_definition.ReadAttributes ();
 
 			Type[] all_types;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/report.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/report.cs
index 633b18586..a656afde8 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/report.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/report.cs
@@ -54,7 +54,7 @@ namespace Mono.CSharp {
 			28, 67, 78,
 			105, 108, 109, 114, 162, 164, 168, 169, 183, 184, 197,
 			219, 251, 252, 253, 278, 282,
-			402, 414, 419, 420, 429, 436, 437, 440, 458, 464, 465, 467, 469, 472,
+			402, 414, 419, 420, 429, 436, 437, 440, 458, 464, 465, 467, 469, 472, 473,
 			612, 618, 626, 628, 642, 649, 652, 657, 658, 659, 660, 661, 665, 672, 675, 693,
 			728,
 			809, 824,
@@ -62,7 +62,7 @@ namespace Mono.CSharp {
 			1522, 1570, 1571, 1572, 1573, 1574, 1580, 1581, 1584, 1587, 1589, 1590, 1591, 1592,
 			1607, 1616, 1633, 1634, 1635, 1685, 1690, 1691, 1692, 1695, 1696, 1699,
 			1700, 1701, 1702, 1709, 1717, 1718, 1720,
-			1901, 1981,
+			1901, 1956, 1981,
 			2002, 2023, 2029,
 			3000, 3001, 3002, 3003, 3005, 3006, 3007, 3008, 3009,
 			3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017, 3018, 3019,
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/roottypes.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/roottypes.cs
index 260259037..c84ed9fce 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/roottypes.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/roottypes.cs
@@ -225,6 +225,10 @@ namespace Mono.CSharp
 			}
 		}
 
+		public bool HasTypesFullyDefined {
+			get; set;
+		}
+
 		//
 		// Returns module global:: namespace
 		//
@@ -397,7 +401,10 @@ namespace Mono.CSharp
 		public new void CreateType ()
 		{
 			// Release cache used by parser only
-			defined_type_containers = null;
+			if (Evaluator == null)
+				defined_type_containers = null;
+			else
+				defined_type_containers.Clear ();
 
 			foreach (TypeContainer tc in types)
 				tc.CreateType ();
@@ -418,6 +425,8 @@ namespace Mono.CSharp
 					throw new InternalErrorException (tc, e);
 				}
 			}
+
+			HasTypesFullyDefined = true;
 		}
 
 		public override void Emit ()
@@ -549,6 +558,7 @@ namespace Mono.CSharp
 
 		protected override void RemoveMemberType (TypeContainer ds)
 		{
+			defined_type_containers.Remove (ds.MemberName);
 			ds.NamespaceEntry.NS.RemoveDeclSpace (ds.Basename);
 			base.RemoveMemberType (ds);
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/statement.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/statement.cs
index e196b2346..6fa3986e1 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/statement.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/statement.cs
@@ -1404,12 +1404,10 @@ namespace Mono.CSharp {
 				}
 
 				if (type == null) {
-					var texpr = type_expr.ResolveAsType (bc);
-					if (texpr == null)
+					type = type_expr.ResolveAsType (bc);
+					if (type == null)
 						return false;
 
-					type = texpr.Type;
-
 					if (li.IsConstant && !type.IsConstantCompatible) {
 						Const.Error_InvalidConstantType (type, loc, bc.Report);
 					}
@@ -1521,7 +1519,7 @@ namespace Mono.CSharp {
 
 			c = c.ConvertImplicitly (li.Type);
 			if (c == null) {
-				if (TypeManager.IsReferenceType (li.Type))
+				if (TypeSpec.IsReferenceType (li.Type))
 					initializer.Error_ConstantCanBeInitializedWithNullOnly (bc, li.Type, initializer.Location, li.Name);
 				else
 					initializer.Error_ValueCannotBeConverted (bc, initializer.Location, li.Type, false);
@@ -1866,7 +1864,7 @@ namespace Mono.CSharp {
 
 		int? resolving_init_idx;
 
-		Block original;
+		protected Block original;
 
 #if DEBUG
 		static int id;
@@ -2334,7 +2332,7 @@ namespace Mono.CSharp {
 							b.am_storey.AddParentStoreyReference (ec, am_storey);
 
 							// Stop propagation inside same top block
-							if (b.ParametersBlock.am_storey == ParametersBlock.am_storey)
+							if (b.ParametersBlock.Original == ParametersBlock.Original)
 								break;
 
 							b = b.ParametersBlock;
@@ -2494,6 +2492,9 @@ namespace Mono.CSharp {
 			ParametersBlock = this;
 		}
 
+		//
+		// It's supposed to be used by method body implementation of anonymous methods
+		//
 		protected ParametersBlock (ParametersBlock source, ParametersCompiled parameters)
 			: base (null, 0, source.StartLocation, source.EndLocation)
 		{
@@ -2506,6 +2507,12 @@ namespace Mono.CSharp {
 			this.am_storey = source.am_storey;
 
 			ParametersBlock = this;
+
+			//
+			// Overwrite original for comparison purposes when linking cross references
+			// between anonymous methods
+			//
+			original = source;
 		}
 
 		#region Properties
@@ -4155,7 +4162,7 @@ namespace Mono.CSharp {
 			if (expr == null)
 				return false;
 
-			if (!TypeManager.IsReferenceType (expr.Type)){
+			if (!TypeSpec.IsReferenceType (expr.Type)) {
 				ec.Report.Error (185, loc,
 					"`{0}' is not a reference type as required by the lock statement",
 					expr.Type.GetSignatureForError ());
@@ -4770,11 +4777,10 @@ namespace Mono.CSharp {
 		{
 			using (ec.With (ResolveContext.Options.CatchScope, true)) {
 				if (type_expr != null) {
-					TypeExpr te = type_expr.ResolveAsType (ec);
-					if (te == null)
+					type = type_expr.ResolveAsType (ec);
+					if (type == null)
 						return false;
 
-					type = te.Type;
 					if (type.BuiltinType != BuiltinTypeSpec.Type.Exception && !TypeSpec.IsBaseClass (type, ec.BuiltinTypes.Exception, false)) {
 						ec.Report.Error (155, loc, "The type caught or thrown must be derived from System.Exception");
 					} else if (li != null) {
@@ -5321,18 +5327,18 @@ namespace Mono.CSharp {
 				if (access == null)
 					return false;
 
-				Expression var_type = for_each.type;
-				VarExpr ve = var_type as VarExpr;
-				if (ve != null) {
+				TypeSpec var_type;
+				if (for_each.type is VarExpr) {
 					// Infer implicitly typed local variable from foreach array type
-					var_type = new TypeExpression (access.Type, ve.Location);
+					var_type = access.Type;
+				} else {
+					var_type = for_each.type.ResolveAsType (ec);
 				}
 
-				var_type = var_type.ResolveAsType (ec);
 				if (var_type == null)
 					return false;
 
-				conv = Convert.ExplicitConversion (ec, access, var_type.Type, loc);
+				conv = Convert.ExplicitConversion (ec, access, var_type, loc);
 				if (conv == null)
 					return false;
 
@@ -5678,29 +5684,31 @@ namespace Mono.CSharp {
 					return false;
 
 				VarExpr ve = var_type as VarExpr;
+
 				if (ve != null) {
 					if (is_dynamic) {
 						// Source type is dynamic, set element type to dynamic too
-						var_type = new TypeExpression (ec.BuiltinTypes.Dynamic, var_type.Location);
+						variable.Type = ec.BuiltinTypes.Dynamic;
 					} else {
 						// Infer implicitly typed local variable from foreach enumerable type
-						var_type = new TypeExpression (current_pe.Type, var_type.Location);
+						variable.Type = current_pe.Type;
+					}
+				} else {
+					if (is_dynamic) {
+						// Explicit cast of dynamic collection elements has to be done at runtime
+						current_pe = EmptyCast.Create (current_pe, ec.BuiltinTypes.Dynamic);
 					}
-				} else if (is_dynamic) {
-					// Explicit cast of dynamic collection elements has to be done at runtime
-					current_pe = EmptyCast.Create (current_pe, ec.BuiltinTypes.Dynamic);
+
+					variable.Type = var_type.ResolveAsType (ec);
 				}
 
-				var_type = var_type.ResolveAsType (ec);
-				if (var_type == null)
+				if (variable.Type == null)
 					return false;
 
-				variable.Type = var_type.Type;
-
 				var init = new Invocation (get_enumerator_mg, null);
 
 				statement = new While (new BooleanExpression (new Invocation (move_next_mg, null)),
-					new Body (var_type.Type, variable, current_pe, statement, loc), loc);
+					new Body (variable.Type, variable, current_pe, statement, loc), loc);
 
 				var enum_type = enumerator_variable.Type;
 
@@ -5708,7 +5716,7 @@ namespace Mono.CSharp {
 				// Add Dispose method call when enumerator can be IDisposable
 				//
 				if (!enum_type.ImplementsInterface (ec.BuiltinTypes.IDisposable, false)) {
-					if (!enum_type.IsSealed && !TypeManager.IsValueType (enum_type)) {
+					if (!enum_type.IsSealed && !TypeSpec.IsValueType (enum_type)) {
 						//
 						// Runtime Dispose check
 						//
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typemanager.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typemanager.cs
index f7bb20207..65725bafc 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typemanager.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typemanager.cs
@@ -801,34 +801,15 @@ namespace Mono.CSharp
 		if (t.IsPointer)
 			return IsUnmanagedType (GetElementType (t));
 
-		if (!IsValueType (t))
+		if (!TypeSpec.IsValueType (t))
 			return false;
 
 		if (t.IsNested && t.DeclaringType.IsGenericOrParentIsGeneric)
 			return false;
 
 		return true;
-	}
-
-	//
-	// Null is considered to be a reference type
-	//			
-	public static bool IsReferenceType (TypeSpec t)
-	{
-		if (t.IsGenericParameter)
-			return ((TypeParameterSpec) t).IsReferenceType;
-
-		return !t.IsStruct && !IsEnumType (t);
-	}			
+	}	
 		
-	public static bool IsValueType (TypeSpec t)
-	{
-		if (t.IsGenericParameter)
-			return ((TypeParameterSpec) t).IsValueType;
-
-		return t.IsStruct || IsEnumType (t);
-	}
-
 	public static bool IsFamilyAccessible (TypeSpec type, TypeSpec parent)
 	{
 //		TypeParameter tparam = LookupTypeParameter (type);
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typespec.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typespec.cs
index bf0816ec9..03fa923fb 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typespec.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Parser/mcs/typespec.cs
@@ -516,6 +516,37 @@ namespace Mono.CSharp
 			return false;
 		}
 
+		public static bool IsReferenceType (TypeSpec t)
+		{
+			switch (t.Kind) {
+			case MemberKind.TypeParameter:
+				return ((TypeParameterSpec) t).IsReferenceType;
+			case MemberKind.Struct:
+			case MemberKind.Enum:
+				return false;
+			case MemberKind.InternalCompilerType:
+				//
+				// Null is considered to be a reference type
+				//			
+				return t == InternalType.NullLiteral || t.BuiltinType == BuiltinTypeSpec.Type.Dynamic;
+			default:
+				return true;
+			}
+		}
+
+		public static bool IsValueType (TypeSpec t)
+		{
+			switch (t.Kind) {
+			case MemberKind.TypeParameter:
+				return ((TypeParameterSpec) t).IsValueType;
+			case MemberKind.Struct:
+			case MemberKind.Enum:
+				return true;
+			default:
+				return false;
+			}
+		}
+
 		public override MemberSpec InflateMember (TypeParameterInflator inflator)
 		{
 			var targs = IsGeneric ? MemberDefinition.TypeParameters : TypeSpec.EmptyTypes;
@@ -664,8 +695,6 @@ namespace Mono.CSharp
 			Exception,
 			Attribute,
 			Other,
-
-			Null,
 		}
 
 		readonly Type type;
@@ -1005,8 +1034,17 @@ namespace Mono.CSharp
 			//
 			public static bool IsEqual (TypeSpec a, TypeSpec b)
 			{
-				if (a.MemberDefinition != b.MemberDefinition)
+				if (a.MemberDefinition != b.MemberDefinition) {
+					var base_ifaces = a.Interfaces;
+					if (base_ifaces != null) {
+						foreach (var base_iface in base_ifaces) {
+							if (base_iface.Arity > 0 && IsEqual (base_iface, b))
+								return true;
+						}
+					}
+
 					return false;
+				}
 
 				var ta = a.TypeArguments;
 				var tb = b.TypeArguments;
@@ -1054,7 +1092,7 @@ namespace Mono.CSharp
 					//    class X<T> : I<T>, I<float>
 					// 
 					if (b.IsGenericParameter)
-						return a.DeclaringType == b.DeclaringType;
+						return a != b && a.DeclaringType == b.DeclaringType;
 
 					//
 					// We're now comparing a type parameter with a
@@ -1141,7 +1179,7 @@ namespace Mono.CSharp
 				if (b_a == null)
 					return false;
 
-				return IsEqual (a_a.Element, b_a.Element) && a_a.Rank == b_a.Rank;
+				return a_a.Rank == b_a.Rank && IsEqual (a_a.Element, b_a.Element);
 			}
 
 			if (!a.IsGeneric || !b.IsGeneric) {
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpAttribute.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpAttribute.cs
new file mode 100644
index 000000000..faec84fa0
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpAttribute.cs
@@ -0,0 +1,140 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	public sealed class CSharpAttribute : Immutable, IAttribute
+	{
+		ITypeReference attributeType;
+		DomRegion region;
+		IList<IConstantValue> positionalArguments;
+		IList<KeyValuePair<string, IConstantValue>> namedCtorArguments;
+		IList<KeyValuePair<string, IConstantValue>> namedArguments;
+		
+		public CSharpAttribute(ITypeReference attributeType, DomRegion region,
+		                       IList<IConstantValue> positionalArguments,
+		                       IList<KeyValuePair<string, IConstantValue>> namedCtorArguments,
+		                       IList<KeyValuePair<string, IConstantValue>> namedArguments)
+		{
+			if (attributeType == null)
+				throw new ArgumentNullException("attributeType");
+			this.attributeType = attributeType;
+			this.region = region;
+			this.positionalArguments = positionalArguments;
+			this.namedCtorArguments = namedCtorArguments;
+			this.namedArguments = namedArguments;
+		}
+		
+		public DomRegion Region {
+			get { return region; }
+		}
+		
+		public ITypeReference AttributeType {
+			get { return attributeType; }
+		}
+		
+		public IMethod ResolveConstructor(ITypeResolveContext context)
+		{
+			IType type = attributeType.Resolve(context);
+			throw new NotImplementedException();
+		}
+		
+		public IList<IConstantValue> GetPositionalArguments(ITypeResolveContext context)
+		{
+			if (namedCtorArguments == null || namedCtorArguments.Count == 0) {
+				// no namedCtorArguments: just return the positionalArguments
+				if (positionalArguments != null)
+					return new ReadOnlyCollection<IConstantValue>(positionalArguments);
+				else
+					return EmptyList<IConstantValue>.Instance;
+			}
+			// we do have namedCtorArguments, which need to be re-ordered and appended to the positional arguments
+			List<IConstantValue> result = new List<IConstantValue>(this.positionalArguments);
+			IMethod method = ResolveConstructor(context);
+			if (method != null) {
+				for (int i = result.Count; i < method.Parameters.Count; i++) {
+					IParameter p = method.Parameters[i];
+					bool found = false;
+					foreach (var pair in namedCtorArguments) {
+						if (pair.Key == p.Name) {
+							result.Add(pair.Value);
+							found = true;
+						}
+					}
+					if (!found) {
+						// add the parameter's default value:
+						result.Add(p.DefaultValue ?? new SimpleConstantValue(p.Type, CSharpResolver.GetDefaultValue(p.Type.Resolve(context))));
+					}
+				}
+			}
+			return result.AsReadOnly();
+		}
+		
+		public IList<KeyValuePair<string, IConstantValue>> GetNamedArguments(ITypeResolveContext context)
+		{
+			if (namedArguments != null)
+				return new ReadOnlyCollection<KeyValuePair<string, IConstantValue>>(namedArguments);
+			else
+				return EmptyList<KeyValuePair<string, IConstantValue>>.Instance;
+		}
+	}
+	
+	/// <summary>
+	/// Type reference used within an attribute.
+	/// Looks up both 'withoutSuffix' and 'withSuffix' and returns the type that exists.
+	/// </summary>
+	public sealed class AttributeTypeReference : ITypeReference, ISupportsInterning
+	{
+		ITypeReference withoutSuffix, withSuffix;
+		
+		public AttributeTypeReference(ITypeReference withoutSuffix, ITypeReference withSuffix)
+		{
+			if (withoutSuffix == null)
+				throw new ArgumentNullException("withoutSuffix");
+			if (withSuffix == null)
+				throw new ArgumentNullException("withSuffix");
+			this.withoutSuffix = withoutSuffix;
+			this.withSuffix = withSuffix;
+		}
+		
+		public IType Resolve(ITypeResolveContext context)
+		{
+			// If both types exist, C# considers that to be an ambiguity, but we are less strict.
+			IType type = withoutSuffix.Resolve(context);
+			if (type == SharedTypes.UnknownType)
+				return withSuffix.Resolve(context);
+			else
+				return type;
+		}
+		
+		public override string ToString()
+		{
+			return withoutSuffix.ToString() + "[Attribute]";
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			withoutSuffix = provider.Intern(withoutSuffix);
+			withSuffix = provider.Intern(withSuffix);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				return withoutSuffix.GetHashCode() + 715613 * withSuffix.GetHashCode();
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			AttributeTypeReference atr = other as AttributeTypeReference;
+			return atr != null && this.withoutSuffix == atr.withoutSuffix && this.withSuffix == atr.withSuffix;
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs
index 2a32d791a..45dcf7f46 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/CSharpResolver.cs
@@ -2043,7 +2043,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		#endregion
 		
 		#region ResolveConditional
-		public ResolveResult ResolveConditional(ResolveResult trueExpression, ResolveResult falseExpression)
+		public ResolveResult ResolveConditional(ResolveResult condition, ResolveResult trueExpression, ResolveResult falseExpression)
 		{
 			// C# 4.0 spec §7.14: Conditional operator
 			
@@ -2052,11 +2052,17 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			Conversions c = new Conversions(context);
 			bool isValid;
 			IType resultType;
-			if (HasType(trueExpression) && HasType(falseExpression)) {
+			if (trueExpression.Type == SharedTypes.Dynamic || falseExpression.Type == SharedTypes.Dynamic) {
+				resultType = SharedTypes.Dynamic;
+				isValid = true;
+			} else if (HasType(trueExpression) && HasType(falseExpression)) {
 				bool t2f = c.ImplicitConversion(trueExpression.Type, falseExpression.Type);
 				bool f2t = c.ImplicitConversion(falseExpression.Type, trueExpression.Type);
-				resultType = (f2t && !t2f) ? falseExpression.Type : trueExpression.Type;
-				isValid = (t2f != f2t) || (t2f && f2t && c.IdentityConversion(trueExpression.Type, falseExpression.Type));
+				resultType = (f2t && !t2f) ? trueExpression.Type : falseExpression.Type;
+				// The operator is valid:
+				// a) if there's a conversion in one direction but not the other
+				// b) if there are conversions in both directions, and the types are equivalent
+				isValid = (t2f != f2t) || (t2f && f2t && trueExpression.Type.Equals(falseExpression.Type));
 			} else if (HasType(trueExpression)) {
 				resultType = trueExpression.Type;
 				isValid = c.ImplicitConversion(falseExpression, resultType);
@@ -2066,7 +2072,18 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			} else {
 				return ErrorResult;
 			}
-			return isValid ? new ResolveResult(resultType) : new ErrorResolveResult(resultType);
+			if (isValid) {
+				if (condition.IsCompileTimeConstant && trueExpression.IsCompileTimeConstant && falseExpression.IsCompileTimeConstant) {
+					bool? val = condition.ConstantValue as bool?;
+					if (val == true)
+						return ResolveCast(resultType, trueExpression);
+					else if (val == false)
+						return ResolveCast(resultType, falseExpression);
+				}
+				return new ResolveResult(resultType);
+			} else {
+				return new ErrorResolveResult(resultType);
+			}
 		}
 		
 		bool HasType(ResolveResult r)
@@ -2087,5 +2104,46 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			}
 		}
 		#endregion
+		
+		#region ResolveDefaultValue
+		public ResolveResult ResolveDefaultValue(IType type)
+		{
+			return new ConstantResolveResult(type, GetDefaultValue(type));
+		}
+		
+		public static object GetDefaultValue(IType type)
+		{
+			switch (ReflectionHelper.GetTypeCode(type)) {
+				case TypeCode.Boolean:
+					return false;
+				case TypeCode.Char:
+					return '\0';
+				case TypeCode.SByte:
+					return (sbyte)0;
+				case TypeCode.Byte:
+					return (byte)0;
+				case TypeCode.Int16:
+					return (short)0;
+				case TypeCode.UInt16:
+					return (ushort)0;
+				case TypeCode.Int32:
+					return 0;
+				case TypeCode.UInt32:
+					return 0U;
+				case TypeCode.Int64:
+					return 0L;
+				case TypeCode.UInt64:
+					return 0UL;
+				case TypeCode.Single:
+					return 0f;
+				case TypeCode.Double:
+					return 0.0;
+				case TypeCode.Decimal:
+					return 0m;
+				default:
+					return null;
+			}
+		}
+		#endregion
 	}
 }
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ConstantValues.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ConstantValues.cs
new file mode 100644
index 000000000..ff1edd29f
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ConstantValues.cs
@@ -0,0 +1,582 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using ICSharpCode.NRefactory.CSharp.Analysis;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
+using ICSharpCode.NRefactory.Utils;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver.ConstantValues
+{
+	// Contains representations for constant C# expressions.
+	// We use these instead of storing the full AST to reduce the memory usage.
+	
+	public sealed class CSharpConstantValue : Immutable, IConstantValue, ISupportsInterning
+	{
+		ConstantExpression expression;
+		UsingScope parentUsingScope;
+		ITypeDefinition parentTypeDefinition;
+		
+		public CSharpConstantValue(ConstantExpression expression, UsingScope parentUsingScope, ITypeDefinition parentTypeDefinition)
+		{
+			if (expression == null)
+				throw new ArgumentNullException("expression");
+			this.expression = expression;
+			this.parentUsingScope = parentUsingScope;
+			this.parentTypeDefinition = parentTypeDefinition;
+		}
+		
+		CSharpResolver CreateResolver(ITypeResolveContext context)
+		{
+			// Because constants are evaluated by the compiler, we need to evaluate them in the resolve context
+			// of the project where they are defined, not in that where the constant value is used.
+			// TODO: how do we get the correct resolve context?
+			return new CSharpResolver(context) {
+				CheckForOverflow = false, // TODO: get project-wide overflow setting
+				CurrentTypeDefinition = parentTypeDefinition,
+				UsingScope = parentUsingScope
+			};
+		}
+		
+		public IType GetValueType(ITypeResolveContext context)
+		{
+			CSharpResolver resolver = CreateResolver(context);
+			IType type = expression.Resolve(resolver).Type;
+			if (resolver.Context != context) {
+				// Retrieve the equivalent type in the new resolve context.
+				// E.g. if the constant is defined in a .NET 2.0 project, type might be Int32 from mscorlib 2.0.
+				// However, the calling project might be a .NET 4.0 project, so we need to return Int32 from mscorlib 4.0.
+				return type.AcceptVisitor(new MapTypeIntoNewContext(context));
+			}
+			return type;
+		}
+		
+		public object GetValue(ITypeResolveContext context)
+		{
+			CSharpResolver resolver = CreateResolver(context);
+			object val = expression.Resolve(resolver).ConstantValue;
+			if (resolver.Context != context) {
+				// If 'val' is a type or an array containing types, we need to map it to the new context.
+				val = MapToNewContext(val, context);
+			}
+			return val;
+		}
+		
+		static object MapToNewContext(object val, ITypeResolveContext context)
+		{
+			IType type = val as IType;
+			if (type != null) {
+				return type.AcceptVisitor(new MapTypeIntoNewContext(context));
+			}
+			object[] arr = val as object[];
+			if (arr != null) {
+				object[] newArr = new object[arr.Length];
+				bool modified = false;
+				for (int i = 0; i < arr.Length; i++) {
+					newArr[i] = MapToNewContext(arr[i], context);
+					modified |= arr[i] != newArr[i];
+				}
+				if (modified)
+					return newArr;
+			}
+			return val;
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			expression = provider.Intern(expression);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			return expression.GetHashCode()
+				^ (parentUsingScope != null ? parentUsingScope.GetHashCode() : 0)
+				^ (parentTypeDefinition != null ? parentTypeDefinition.GetHashCode() : 0);
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			CSharpConstantValue cv = other as CSharpConstantValue;
+			return cv != null
+				&& expression == cv.expression
+				&& parentUsingScope == cv.parentUsingScope
+				&& parentTypeDefinition == cv.parentTypeDefinition;
+		}
+	}
+	
+	public abstract class ConstantExpression
+	{
+		public abstract ResolveResult Resolve(CSharpResolver resolver);
+	}
+	
+	/// <summary>
+	/// C#'s equivalent to the SimpleConstantValue.
+	/// </summary>
+	public sealed class PrimitiveConstantExpression : ConstantExpression, ISupportsInterning
+	{
+		ITypeReference type;
+		object value;
+		
+		public ITypeReference Type {
+			get { return type; }
+		}
+		
+		public object Value {
+			get { return value; }
+		}
+		
+		public PrimitiveConstantExpression(ITypeReference type, object value)
+		{
+			if (type == null)
+				throw new ArgumentNullException("type");
+			this.type = type;
+			this.value = value;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			object val = value;
+			if (val is ITypeReference)
+				val = ((ITypeReference)val).Resolve(resolver.Context);
+			return new ConstantResolveResult(type.Resolve(resolver.Context), val);
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			type = provider.Intern(type);
+			value = provider.Intern(value);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			return type.GetHashCode() ^ (value != null ? value.GetHashCode() : 0);
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			PrimitiveConstantExpression scv = other as PrimitiveConstantExpression;
+			return scv != null && type == scv.type && value == scv.value;
+		}
+	}
+	
+	public sealed class ConstantCast : ConstantExpression, ISupportsInterning
+	{
+		ITypeReference targetType;
+		ConstantExpression expression;
+		
+		public ConstantCast(ITypeReference targetType, ConstantExpression expression)
+		{
+			if (targetType == null)
+				throw new ArgumentNullException("targetType");
+			if (expression == null)
+				throw new ArgumentNullException("expression");
+			this.targetType = targetType;
+			this.expression = expression;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			return resolver.ResolveCast(targetType.Resolve(resolver.Context), expression.Resolve(resolver));
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			targetType = provider.Intern(targetType);
+			expression = provider.Intern(expression);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				return targetType.GetHashCode() + expression.GetHashCode() * 1018829;
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantCast cast = other as ConstantCast;
+			return cast != null
+				&& this.targetType == cast.targetType && this.expression == cast.expression;
+		}
+	}
+	
+	public sealed class ConstantIdentifierReference : ConstantExpression, ISupportsInterning
+	{
+		string identifier;
+		IList<ITypeReference> typeArguments;
+		
+		public ConstantIdentifierReference(string identifier, IList<ITypeReference> typeArguments = null)
+		{
+			if (identifier == null)
+				throw new ArgumentNullException("identifier");
+			this.identifier = identifier;
+			this.typeArguments = typeArguments;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			return resolver.ResolveSimpleName(identifier, ResolveTypes(resolver, typeArguments));
+		}
+		
+		internal static IList<IType> ResolveTypes(CSharpResolver resolver, IList<ITypeReference> typeArguments)
+		{
+			if (typeArguments == null)
+				return EmptyList<IType>.Instance;
+			IType[] types = new IType[typeArguments.Count];
+			for (int i = 0; i < types.Length; i++) {
+				types[i] = typeArguments[i].Resolve(resolver.Context);
+			}
+			return types;
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			identifier = provider.Intern(identifier);
+			typeArguments = provider.InternList(typeArguments);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				int hashCode = identifier.GetHashCode();
+				if (typeArguments != null)
+					hashCode ^= typeArguments.GetHashCode();
+				return hashCode;
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantIdentifierReference cir = other as ConstantIdentifierReference;
+			return cir != null &&
+				this.identifier == cir.identifier && this.typeArguments == cir.typeArguments;
+		}
+	}
+	
+	public sealed class ConstantMemberReference : ConstantExpression, ISupportsInterning
+	{
+		ITypeReference targetType;
+		ConstantExpression targetExpression;
+		string memberName;
+		IList<ITypeReference> typeArguments;
+		
+		public ConstantMemberReference(ITypeReference targetType, string memberName, IList<ITypeReference> typeArguments = null)
+		{
+			if (targetType == null)
+				throw new ArgumentNullException("targetType");
+			if (memberName == null)
+				throw new ArgumentNullException("memberName");
+			this.targetType = targetType;
+			this.memberName = memberName;
+			this.typeArguments = typeArguments;
+		}
+		
+		public ConstantMemberReference(ConstantExpression targetExpression, string memberName, IList<ITypeReference> typeArguments = null)
+		{
+			if (targetExpression == null)
+				throw new ArgumentNullException("targetExpression");
+			if (memberName == null)
+				throw new ArgumentNullException("memberName");
+			this.targetExpression = targetExpression;
+			this.memberName = memberName;
+			this.typeArguments = typeArguments;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			ResolveResult rr;
+			if (targetType != null)
+				rr = new TypeResolveResult(targetType.Resolve(resolver.Context));
+			else
+				rr = targetExpression.Resolve(resolver);
+			return resolver.ResolveMemberAccess(rr, memberName, ConstantIdentifierReference.ResolveTypes(resolver, typeArguments));
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			targetType = provider.Intern(targetType);
+			targetExpression = provider.Intern(targetExpression);
+			memberName = provider.Intern(memberName);
+			typeArguments = provider.InternList(typeArguments);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				int hashCode;
+				if (targetType != null)
+					hashCode = targetType.GetHashCode();
+				else
+					hashCode = targetExpression.GetHashCode();
+				hashCode ^= memberName.GetHashCode();
+				if (typeArguments != null)
+					hashCode ^= typeArguments.GetHashCode();
+				return hashCode;
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantMemberReference cmr = other as ConstantMemberReference;
+			return cmr != null
+				&& this.targetType == cmr.targetType && this.targetExpression == cmr.targetExpression
+				&& this.memberName == cmr.memberName && this.typeArguments == cmr.typeArguments;
+		}
+	}
+	
+	public sealed class ConstantCheckedExpression : ConstantExpression, ISupportsInterning
+	{
+		bool checkForOverflow;
+		ConstantExpression expression;
+		
+		public ConstantCheckedExpression(bool checkForOverflow, ConstantExpression expression)
+		{
+			if (expression == null)
+				throw new ArgumentNullException("expression");
+			this.checkForOverflow = checkForOverflow;
+			this.expression = expression;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			bool oldCheckForOverflow = resolver.CheckForOverflow;
+			try {
+				resolver.CheckForOverflow = this.checkForOverflow;
+				return expression.Resolve(resolver);
+			} finally {
+				resolver.CheckForOverflow = oldCheckForOverflow;
+			}
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			expression = provider.Intern(expression);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			return expression.GetHashCode() ^ (checkForOverflow ? 161851612 : 75163517);
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantCheckedExpression cce = other as ConstantCheckedExpression;
+			return cce != null
+				&& this.expression == cce.expression
+				&& this.checkForOverflow == cce.checkForOverflow;
+		}
+	}
+	
+	public sealed class ConstantDefaultValue : ConstantExpression, ISupportsInterning
+	{
+		ITypeReference type;
+		
+		public ConstantDefaultValue(ITypeReference type)
+		{
+			if (type == null)
+				throw new ArgumentNullException("type");
+			this.type = type;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			return resolver.ResolveDefaultValue(type.Resolve(resolver.Context));
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			type = provider.Intern(type);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			return type.GetHashCode();
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantDefaultValue o = other as ConstantDefaultValue;
+			return o != null && this.type == o.type;
+		}
+	}
+	
+	public sealed class ConstantUnaryOperator : ConstantExpression, ISupportsInterning
+	{
+		UnaryOperatorType operatorType;
+		ConstantExpression expression;
+		
+		public ConstantUnaryOperator(UnaryOperatorType operatorType, ConstantExpression expression)
+		{
+			if (expression == null)
+				throw new ArgumentNullException("expression");
+			this.operatorType = operatorType;
+			this.expression = expression;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			return resolver.ResolveUnaryOperator(operatorType, expression.Resolve(resolver));
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			expression = provider.Intern(expression);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				return expression.GetHashCode() * 811 + operatorType.GetHashCode();
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantUnaryOperator uop = other as ConstantUnaryOperator;
+			return uop != null
+				&& this.operatorType == uop.operatorType
+				&& this.expression == uop.expression;
+		}
+	}
+
+	public sealed class ConstantBinaryOperator : ConstantExpression, ISupportsInterning
+	{
+		ConstantExpression left;
+		BinaryOperatorType operatorType;
+		ConstantExpression right;
+		
+		public ConstantBinaryOperator(ConstantExpression left, BinaryOperatorType operatorType, ConstantExpression right)
+		{
+			if (left == null)
+				throw new ArgumentNullException("left");
+			if (right == null)
+				throw new ArgumentNullException("right");
+			this.left = left;
+			this.operatorType = operatorType;
+			this.right = right;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			ResolveResult lhs = left.Resolve(resolver);
+			ResolveResult rhs = right.Resolve(resolver);
+			return resolver.ResolveBinaryOperator(operatorType, lhs, rhs);
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			left = provider.Intern(left);
+			right = provider.Intern(right);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				return left.GetHashCode() * 811 + operatorType.GetHashCode() + right.GetHashCode() * 91781;
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantBinaryOperator bop = other as ConstantBinaryOperator;
+			return bop != null
+				&& this.operatorType == bop.operatorType
+				&& this.left == bop.left && this.right == bop.right;
+		}
+	}
+	
+	public sealed class ConstantConditionalOperator : ConstantExpression, ISupportsInterning
+	{
+		ConstantExpression condition, trueExpr, falseExpr;
+		
+		public ConstantConditionalOperator(ConstantExpression condition, ConstantExpression trueExpr, ConstantExpression falseExpr)
+		{
+			if (condition == null)
+				throw new ArgumentNullException("condition");
+			if (trueExpr == null)
+				throw new ArgumentNullException("trueExpr");
+			if (falseExpr == null)
+				throw new ArgumentNullException("falseExpr");
+			this.condition = condition;
+			this.trueExpr = trueExpr;
+			this.falseExpr = falseExpr;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			return resolver.ResolveConditional(
+				condition.Resolve(resolver),
+				trueExpr.Resolve(resolver),
+				falseExpr.Resolve(resolver)
+			);
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			condition = provider.Intern(condition);
+			trueExpr = provider.Intern(trueExpr);
+			falseExpr = provider.Intern(falseExpr);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			unchecked {
+				return condition.GetHashCode() * 182981713
+					+ trueExpr.GetHashCode() * 917517169
+					+ falseExpr.GetHashCode() * 611651;
+			}
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantConditionalOperator coo = other as ConstantConditionalOperator;
+			return coo != null
+				&& this.condition == coo.condition
+				&& this.trueExpr == coo.trueExpr
+				&& this.falseExpr == coo.falseExpr;
+		}
+	}
+	
+	/// <summary>
+	/// Represents an array creation (as used within an attribute argument)
+	/// </summary>
+	public sealed class ConstantArrayCreation : ConstantExpression, ISupportsInterning
+	{
+		// type may be null when the element is being inferred
+		ITypeReference type;
+		IList<ConstantExpression> arrayElements;
+		
+		public ConstantArrayCreation(ITypeReference type, IList<ConstantExpression> arrayElements)
+		{
+			if (arrayElements == null)
+				throw new ArgumentNullException("arrayElements");
+			this.type = type;
+			this.arrayElements = arrayElements;
+		}
+		
+		public override ResolveResult Resolve(CSharpResolver resolver)
+		{
+			throw new NotImplementedException();
+		}
+		
+		void ISupportsInterning.PrepareForInterning(IInterningProvider provider)
+		{
+			type = provider.Intern(type);
+			arrayElements = provider.InternList(arrayElements);
+		}
+		
+		int ISupportsInterning.GetHashCodeForInterning()
+		{
+			return (type != null ? type.GetHashCode() : 0) ^ arrayElements.GetHashCode();
+		}
+		
+		bool ISupportsInterning.EqualsForInterning(ISupportsInterning other)
+		{
+			ConstantArrayCreation cac = other as ConstantArrayCreation;
+			return cac != null && this.type == cac.type && this.arrayElements == cac.arrayElements;
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MapTypeIntoNewContext.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MapTypeIntoNewContext.cs
new file mode 100644
index 000000000..026ff6bf9
--- /dev/null
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MapTypeIntoNewContext.cs
@@ -0,0 +1,49 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.NRefactory.TypeSystem;
+using ICSharpCode.NRefactory.TypeSystem.Implementation;
+using ICSharpCode.NRefactory.Utils;
+
+namespace ICSharpCode.NRefactory.CSharp.Resolver
+{
+	/// <summary>
+	/// Converts a type by replacing all type definitions with the equivalent definitions in the new context.
+	/// </summary>
+	sealed class MapTypeIntoNewContext : TypeVisitor
+	{
+		readonly ITypeResolveContext context;
+		
+		public MapTypeIntoNewContext(ITypeResolveContext context)
+		{
+			if (context == null)
+				throw new ArgumentNullException("context");
+			this.context = context;
+		}
+		
+		public override IType VisitTypeDefinition(ITypeDefinition type)
+		{
+			if (type.DeclaringTypeDefinition != null) {
+				ITypeDefinition decl = type.DeclaringTypeDefinition.AcceptVisitor(this) as ITypeDefinition;
+				if (decl != null) {
+					foreach (ITypeDefinition c in decl.InnerClasses) {
+						if (c.Name == type.Name && c.TypeParameterCount == type.TypeParameterCount)
+							return c;
+					}
+				}
+				return type;
+			} else {
+				return context.GetClass(type.Namespace, type.Name, type.TypeParameterCount, StringComparer.Ordinal) ?? type;
+			}
+		}
+		
+		public override IType VisitTypeParameter(ITypeParameter type)
+		{
+			// TODO: how to map type parameters?
+			// It might have constraints, and those constraints might be mutually recursive.
+			// Maybe reintroduce ITypeParameter.Owner?
+			throw new NotImplementedException();
+		}
+	}
+}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MemberTypeOrNamespaceReference.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MemberTypeOrNamespaceReference.cs
index 350701a0e..c6c9e00a4 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MemberTypeOrNamespaceReference.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/MemberTypeOrNamespaceReference.cs
@@ -31,6 +31,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			this.parentUsingScope = parentUsingScope;
 		}
 		
+		/// <summary>
+		/// Adds a suffix to the identifier.
+		/// Does not modify the existing type reference, but returns a new one.
+		/// </summary>
+		public MemberTypeOrNamespaceReference AddSuffix(string suffix)
+		{
+			return new MemberTypeOrNamespaceReference(target, identifier + suffix, typeArguments, parentTypeDefinition, parentUsingScope);
+		}
+		
 		public ResolveResult DoResolve(ITypeResolveContext context)
 		{
 			ResolveResult targetRR = target.DoResolve(context);
@@ -48,11 +57,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		public NamespaceResolveResult ResolveNamespace(ITypeResolveContext context)
 		{
+			// TODO: use resolve context for original project, if possible
 			return DoResolve(context) as NamespaceResolveResult;
 		}
 		
 		public IType Resolve(ITypeResolveContext context)
 		{
+			// TODO: use resolve context for original project, if possible; then map the result type into the new context
 			TypeResolveResult rr = DoResolve(context) as TypeResolveResult;
 			return rr != null ? rr.Type : SharedTypes.UnknownType;
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs
index 1403107ad..3bcea943b 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/ResolveVisitor.cs
@@ -567,9 +567,10 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public override ResolveResult VisitConditionalExpression(ConditionalExpression conditionalExpression, object data)
 		{
 			if (resolverEnabled) {
-				Scan(conditionalExpression.Condition);
-				return resolver.ResolveConditional(Resolve(conditionalExpression.TrueExpression),
-				                                   Resolve(conditionalExpression.FalseExpression));
+				return resolver.ResolveConditional(
+					Resolve(conditionalExpression.Condition),
+					Resolve(conditionalExpression.TrueExpression),
+					Resolve(conditionalExpression.FalseExpression));
 			} else {
 				ScanChildren(conditionalExpression);
 				return null;
@@ -579,7 +580,7 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		public override ResolveResult VisitDefaultValueExpression(DefaultValueExpression defaultValueExpression, object data)
 		{
 			if (resolverEnabled) {
-				return new ConstantResolveResult(ResolveType(defaultValueExpression.Type), null);
+				return resolver.ResolveDefaultValue(ResolveType(defaultValueExpression.Type));
 			} else {
 				ScanChildren(defaultValueExpression);
 				return null;
diff --git a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/SimpleTypeOrNamespaceReference.cs b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/SimpleTypeOrNamespaceReference.cs
index a500e85e0..12699dd1c 100644
--- a/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/SimpleTypeOrNamespaceReference.cs
+++ b/NRefactory/ICSharpCode.NRefactory/CSharp/Resolver/SimpleTypeOrNamespaceReference.cs
@@ -29,6 +29,15 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 			this.isInUsingDeclaration = isInUsingDeclaration;
 		}
 		
+		/// <summary>
+		/// Adds a suffix to the identifier.
+		/// Does not modify the existing type reference, but returns a new one.
+		/// </summary>
+		public SimpleTypeOrNamespaceReference AddSuffix(string suffix)
+		{
+			return new SimpleTypeOrNamespaceReference(identifier + suffix, typeArguments, parentTypeDefinition, parentUsingScope, isInUsingDeclaration);
+		}
+		
 		public ResolveResult DoResolve(ITypeResolveContext context)
 		{
 			CSharpResolver r = new CSharpResolver(context);
@@ -43,11 +52,13 @@ namespace ICSharpCode.NRefactory.CSharp.Resolver
 		
 		public NamespaceResolveResult ResolveNamespace(ITypeResolveContext context)
 		{
+			// TODO: use resolve context for original project, if possible
 			return DoResolve(context) as NamespaceResolveResult;
 		}
 		
 		public IType Resolve(ITypeResolveContext context)
 		{
+			// TODO: use resolve context for original project, if possible; then map the result type into the new context
 			TypeResolveResult rr = DoResolve(context) as TypeResolveResult;
 			return rr != null ? rr.Type : SharedTypes.UnknownType;
 		}
diff --git a/NRefactory/ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj b/NRefactory/ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj
index ca88df188..6583c3d4c 100644
--- a/NRefactory/ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj
+++ b/NRefactory/ICSharpCode.NRefactory/ICSharpCode.NRefactory.csproj
@@ -31,6 +31,7 @@
     <Optimize>False</Optimize>
     <DefineConstants>DEBUG;TRACE;FULL_AST</DefineConstants>
     <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
+    <DebugSymbols>true</DebugSymbols>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
     <OutputPath>bin\Release\</OutputPath>
@@ -41,7 +42,6 @@
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <WarningLevel>4</WarningLevel>
-    <DebugSymbols>true</DebugSymbols>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <WarningLevel>4</WarningLevel>
@@ -97,6 +97,9 @@
     <Compile Include="CSharp\Ast\Expressions\UncheckedExpression.cs" />
     <Compile Include="CSharp\Ast\GeneralScope\TypeParameterDeclaration.cs" />
     <Compile Include="CSharp\Ast\MemberType.cs" />
+    <Compile Include="CSharp\Resolver\CSharpAttribute.cs" />
+    <Compile Include="CSharp\Resolver\ConstantValues.cs" />
+    <Compile Include="CSharp\Resolver\MapTypeIntoNewContext.cs" />
     <Compile Include="PatternMatching\BacktrackingInfo.cs" />
     <Compile Include="PatternMatching\Choice.cs" />
     <Compile Include="PatternMatching\AnyNode.cs" />
diff --git a/NRefactory/ICSharpCode.NRefactory/PatternMatching/INode.cs b/NRefactory/ICSharpCode.NRefactory/PatternMatching/INode.cs
index ccd8db499..4e54cff3e 100644
--- a/NRefactory/ICSharpCode.NRefactory/PatternMatching/INode.cs
+++ b/NRefactory/ICSharpCode.NRefactory/PatternMatching/INode.cs
@@ -10,13 +10,13 @@ namespace ICSharpCode.NRefactory.PatternMatching
 	/// </summary>
 	public interface INode
 	{
-		CSharp.Role Role { get; }
+		Role Role { get; }
 		INode FirstChild { get; }
 		INode NextSibling { get; }
 		bool IsNull { get; }
 		
 		bool DoMatch(INode other, Match match);
-		bool DoMatchCollection(CSharp.Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo);
+		bool DoMatchCollection(Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo);
 	}
 	
 	public static class PatternExtensions
diff --git a/NRefactory/ICSharpCode.NRefactory/PatternMatching/OptionalNode.cs b/NRefactory/ICSharpCode.NRefactory/PatternMatching/OptionalNode.cs
index a135a6a58..b42db0209 100644
--- a/NRefactory/ICSharpCode.NRefactory/PatternMatching/OptionalNode.cs
+++ b/NRefactory/ICSharpCode.NRefactory/PatternMatching/OptionalNode.cs
@@ -26,7 +26,7 @@ namespace ICSharpCode.NRefactory.PatternMatching
 		{
 		}
 		
-		public override bool DoMatchCollection(CSharp.Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
+		public override bool DoMatchCollection(Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
 		{
 			backtrackingInfo.backtrackingStack.Push(new PossibleMatch(pos, match.CheckPoint()));
 			return childNode.DoMatch(pos, match);
diff --git a/NRefactory/ICSharpCode.NRefactory/PatternMatching/Pattern.cs b/NRefactory/ICSharpCode.NRefactory/PatternMatching/Pattern.cs
index c1fbc7f66..5553840af 100644
--- a/NRefactory/ICSharpCode.NRefactory/PatternMatching/Pattern.cs
+++ b/NRefactory/ICSharpCode.NRefactory/PatternMatching/Pattern.cs
@@ -29,7 +29,7 @@ namespace ICSharpCode.NRefactory.PatternMatching
 			get { return false; }
 		}
 		
-		CSharp.Role INode.Role {
+		Role INode.Role {
 			get { return null; }
 		}
 		
@@ -43,7 +43,7 @@ namespace ICSharpCode.NRefactory.PatternMatching
 		
 		public abstract bool DoMatch(INode other, Match match);
 		
-		public virtual bool DoMatchCollection(CSharp.Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
+		public virtual bool DoMatchCollection(Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
 		{
 			return DoMatch (pos, match);
 		}
@@ -60,7 +60,7 @@ namespace ICSharpCode.NRefactory.PatternMatching
 			return w.ToString();
 		}
 		
-		public static bool DoMatchCollection(CSharp.Role role, INode firstPatternChild, INode firstOtherChild, Match match)
+		public static bool DoMatchCollection(Role role, INode firstPatternChild, INode firstOtherChild, Match match)
 		{
 			BacktrackingInfo backtrackingInfo = new BacktrackingInfo();
 			Stack<INode> patternStack = new Stack<INode>();
diff --git a/NRefactory/ICSharpCode.NRefactory/PatternMatching/Repeat.cs b/NRefactory/ICSharpCode.NRefactory/PatternMatching/Repeat.cs
index b6694c814..249075fe3 100644
--- a/NRefactory/ICSharpCode.NRefactory/PatternMatching/Repeat.cs
+++ b/NRefactory/ICSharpCode.NRefactory/PatternMatching/Repeat.cs
@@ -30,7 +30,7 @@ namespace ICSharpCode.NRefactory.PatternMatching
 			this.MaxCount = int.MaxValue;
 		}
 		
-		public override bool DoMatchCollection(CSharp.Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
+		public override bool DoMatchCollection(Role role, INode pos, Match match, BacktrackingInfo backtrackingInfo)
 		{
 			var backtrackingStack = backtrackingInfo.backtrackingStack;
 			Debug.Assert(pos == null || pos.Role == role);
diff --git a/NRefactory/ICSharpCode.NRefactory/TypeSystem/ArrayType.cs b/NRefactory/ICSharpCode.NRefactory/TypeSystem/ArrayType.cs
index 6e7d27f40..db590e2b9 100644
--- a/NRefactory/ICSharpCode.NRefactory/TypeSystem/ArrayType.cs
+++ b/NRefactory/ICSharpCode.NRefactory/TypeSystem/ArrayType.cs
@@ -113,7 +113,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		}
 	}
 	
-	public class ArrayTypeReference : ITypeReference, ISupportsInterning
+	public sealed class ArrayTypeReference : ITypeReference, ISupportsInterning
 	{
 		ITypeReference elementType;
 		int dimensions;
diff --git a/NRefactory/ICSharpCode.NRefactory/TypeSystem/IAttribute.cs b/NRefactory/ICSharpCode.NRefactory/TypeSystem/IAttribute.cs
index 42f913f45..ff6abe9eb 100644
--- a/NRefactory/ICSharpCode.NRefactory/TypeSystem/IAttribute.cs
+++ b/NRefactory/ICSharpCode.NRefactory/TypeSystem/IAttribute.cs
@@ -29,12 +29,12 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		/// <summary>
 		/// Gets the positional arguments passed to the attribute.
 		/// </summary>
-		IList<IConstantValue> PositionalArguments { get; }
+		IList<IConstantValue> GetPositionalArguments(ITypeResolveContext context);
 		
 		/// <summary>
 		/// Gets the named arguments passed to the attribute.
 		/// </summary>
-		IList<KeyValuePair<string, IConstantValue>> NamedArguments { get; }
+		IList<KeyValuePair<string, IConstantValue>> GetNamedArguments(ITypeResolveContext context);
 		
 		/// <summary>
 		/// Resolves the constructor method used for this attribute invocation.
@@ -58,18 +58,24 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			}
 		}
 		
-		IList<IConstantValue> IAttribute.PositionalArguments {
-			get {
-				Contract.Ensures(Contract.Result<IList<IConstantValue>>() != null);
-				return null;
-			}
+		IList<IConstantValue> IAttribute.GetPositionalArguments(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<IConstantValue>>() != null);
+			return null;
 		}
 		
-		IList<KeyValuePair<string, IConstantValue>> IAttribute.NamedArguments {
-			get {
-				Contract.Ensures(Contract.Result<IList<KeyValuePair<string, IConstantValue>>>() != null);
-				return null;
-			}
+		IList<KeyValuePair<string, IConstantValue>> IAttribute.GetNamedArguments(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			Contract.Ensures(Contract.Result<IList<KeyValuePair<string, IConstantValue>>>() != null);
+			return null;
+		}
+		
+		IMethod IAttribute.ResolveConstructor(ITypeResolveContext context)
+		{
+			Contract.Requires(context != null);
+			return null;
 		}
 	}
 	#endif
diff --git a/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs b/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs
index ef6568eda..f2e1bc5a5 100644
--- a/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs
+++ b/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeDefinition.cs
@@ -128,6 +128,10 @@ namespace ICSharpCode.NRefactory.TypeSystem
 			return null;
 		}
 		
+		bool ITypeDefinition.HasExtensionMethods {
+			get { return default(bool); }
+		}
+		
 		#region IEntity
 		EntityType IEntity.EntityType {
 			get { return EntityType.None; }
diff --git a/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs b/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs
index 222c06ff1..f9a0cc3cd 100644
--- a/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs
+++ b/NRefactory/ICSharpCode.NRefactory/TypeSystem/ITypeParameter.cs
@@ -33,7 +33,7 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		IList<IAttribute> Attributes { get; }
 		
 		/// <summary>
-		/// Gets the contraints of this type parameter.
+		/// Gets the constraints of this type parameter.
 		/// </summary>
 		IList<ITypeReference> Constraints { get; }
 		
@@ -154,6 +154,14 @@ namespace ICSharpCode.NRefactory.TypeSystem
 		void IFreezable.Freeze()
 		{
 		}
+		
+		EntityType ITypeParameter.OwnerType {
+			get { return EntityType.None; }
+		}
+		
+		DomRegion ITypeParameter.Region {
+			get { return DomRegion.Empty; }
+		}
 	}
 	#endif
 }
diff --git a/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs b/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs
index 8607ffca8..15f8a1815 100644
--- a/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs
+++ b/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultAttribute.cs
@@ -68,6 +68,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
+		IList<IConstantValue> IAttribute.GetPositionalArguments(ITypeResolveContext context)
+		{
+			return this.PositionalArguments;
+		}
+		
 		public IList<KeyValuePair<string, IConstantValue>> NamedArguments {
 			get {
 				if (namedArguments == null)
@@ -76,6 +81,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
+		IList<KeyValuePair<string, IConstantValue>> IAttribute.GetNamedArguments(ITypeResolveContext context)
+		{
+			return this.NamedArguments;
+		}
+		
 		public IMethod ResolveConstructor(ITypeResolveContext context)
 		{
 			IType[] parameterTypes = null;
diff --git a/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs b/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs
index f1ddcc5c0..fded74f5f 100644
--- a/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs
+++ b/NRefactory/ICSharpCode.NRefactory/TypeSystem/Implementation/DefaultTypeParameter.cs
@@ -12,7 +12,7 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 	/// <summary>
 	/// Default implementation of <see cref="ITypeParameter"/>.
 	/// </summary>
-	public class DefaultTypeParameter : AbstractFreezable, ITypeParameter, ISupportsInterning
+	public sealed class DefaultTypeParameter : AbstractFreezable, ITypeParameter, ISupportsInterning
 	{
 		string name;
 		int index;
@@ -188,11 +188,11 @@ namespace ICSharpCode.NRefactory.TypeSystem.Implementation
 			}
 		}
 		
-		public virtual IType BoundTo {
+		IType ITypeParameter.BoundTo {
 			get { return null; }
 		}
 		
-		public virtual ITypeParameter UnboundTypeParameter {
+		ITypeParameter ITypeParameter.UnboundTypeParameter {
 			get { return null; }
 		}
 		
diff --git a/NRefactory/NRefactory.sln b/NRefactory/NRefactory.sln
index 34139cd5d..c96b7b6f7 100644
--- a/NRefactory/NRefactory.sln
+++ b/NRefactory/NRefactory.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-# SharpDevelop 4.0.1.7129
+# SharpDevelop 4.1.0.7372-alpha
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{DC98210E-1646-483B-819A-2BB8272461E4}"
 	ProjectSection(SolutionItems) = postProject
 		README = README
@@ -12,16 +12,14 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.NRefactory", "I
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.NRefactory.Tests", "ICSharpCode.NRefactory.Tests\ICSharpCode.NRefactory.Tests.csproj", "{63D3B27A-D966-4902-90B3-30290E1692F1}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.NRefactory.Demo", "ICSharpCode.NRefactory.Demo\ICSharpCode.NRefactory.Demo.csproj", "{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}"
-EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "VBAstGenerator", "VBAstGenerator\VBAstGenerator.csproj", "{B22522AA-B5BF-4A58-AC6D-D4B45805521F}"
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.NRefactory.VB", "ICSharpCode.NRefactory.VB\ICSharpCode.NRefactory.VB.csproj", "{7B82B671-419F-45F4-B778-D9286F996EFA}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.NRefactory.VB.Tests", "ICSharpCode.NRefactory.VB.Tests\ICSharpCode.NRefactory.VB.Tests.csproj", "{870115DD-960A-4406-A6B9-600BCDC36A03}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Mono.Cecil", "..\Mono.Cecil\Mono.Cecil.csproj", "{D68133BD-1E63-496E-9EDE-4FBDBF77B486}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ICSharpCode.NRefactory.Demo", "ICSharpCode.NRefactory.Demo\ICSharpCode.NRefactory.Demo.csproj", "{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -38,22 +36,6 @@ Global
 		{63D3B27A-D966-4902-90B3-30290E1692F1}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{63D3B27A-D966-4902-90B3-30290E1692F1}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{63D3B27A-D966-4902-90B3-30290E1692F1}.Release|Any CPU.Build.0 = Release|Any CPU
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|Any CPU.Build.0 = Debug|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|Any CPU.ActiveCfg = Debug|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|Any CPU.Build.0 = Release|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|Any CPU.ActiveCfg = Release|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|x86.Build.0 = Debug|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|x86.ActiveCfg = Debug|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|x86.Build.0 = Release|x86
-		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|x86.ActiveCfg = Release|x86
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Debug|x86.Build.0 = Debug|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Debug|x86.ActiveCfg = Debug|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Release|Any CPU.Build.0 = Release|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Release|x86.Build.0 = Release|Any CPU
-		{B22522AA-B5BF-4A58-AC6D-D4B45805521F}.Release|x86.ActiveCfg = Release|Any CPU
 		{7B82B671-419F-45F4-B778-D9286F996EFA}.Debug|Any CPU.Build.0 = Debug|x86
 		{7B82B671-419F-45F4-B778-D9286F996EFA}.Debug|Any CPU.ActiveCfg = Debug|x86
 		{7B82B671-419F-45F4-B778-D9286F996EFA}.Debug|x86.Build.0 = Debug|x86
@@ -78,6 +60,14 @@ Global
 		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|Any CPU.ActiveCfg = net_3_5_Release|Any CPU
 		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.Build.0 = net_4_0_Debug|Any CPU
 		{D68133BD-1E63-496E-9EDE-4FBDBF77B486}.Release|x86.ActiveCfg = net_3_5_Release|Any CPU
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|Any CPU.Build.0 = Debug|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|Any CPU.ActiveCfg = Debug|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|x86.Build.0 = Debug|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Debug|x86.ActiveCfg = Debug|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|Any CPU.Build.0 = Release|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|Any CPU.ActiveCfg = Release|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|x86.Build.0 = Release|x86
+		{9C19E629-C93E-4ACB-9A4B-13072B5AEF9D}.Release|x86.ActiveCfg = Release|x86
 	EndGlobalSection
 	GlobalSection(MonoDevelopProperties) = preSolution
 		StartupItem = ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj
diff --git a/NRefactory/VBAstGenerator/.gitignore b/NRefactory/VBAstGenerator/.gitignore
deleted file mode 100644
index 9ce745d95..000000000
--- a/NRefactory/VBAstGenerator/.gitignore
+++ /dev/null
@@ -1,3 +0,0 @@
-
-bin/
-obj/
\ No newline at end of file
diff --git a/NRefactory/VBAstGenerator/AssemblyInfo.cs b/NRefactory/VBAstGenerator/AssemblyInfo.cs
deleted file mode 100644
index 8139fe99c..000000000
--- a/NRefactory/VBAstGenerator/AssemblyInfo.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System.Reflection;
-using System.Runtime.CompilerServices;
-
-// Information about this assembly is defined by the following
-// attributes.
-//
-// change them to the information which is associated with the assembly
-// you compile.
-
-[assembly: AssemblyTitle("VB Ast Generator")]
-[assembly: AssemblyDescription("Parser and refactoring library for VB.NET")]
-[assembly: AssemblyConfiguration("")]
-[assembly: AssemblyCompany("ic#code")]
-[assembly: AssemblyProduct("SharpDevelop")]
-[assembly: AssemblyCopyright("2006 AlphaSierraPapa")]
-[assembly: AssemblyTrademark("")]
-[assembly: AssemblyCulture("")]
-
-// The assembly version has following format :
-//
-// Major.Minor.Build.Revision
-//
-// You can specify all values by your own or you can build default build and revision
-// numbers with the '*' character (the default):
-
-[assembly: AssemblyVersion("2.0.0.1")]
diff --git a/NRefactory/VBAstGenerator/Ast/Expressions.cs b/NRefactory/VBAstGenerator/Ast/Expressions.cs
deleted file mode 100644
index f0a1701d2..000000000
--- a/NRefactory/VBAstGenerator/Ast/Expressions.cs
+++ /dev/null
@@ -1,372 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace VBAstGenerator.Ast
-{
-	[CustomImplementation]
-	abstract class Expression : AbstractNode, INullable {}
-	
-	[CustomImplementation]
-	class PrimitiveExpression : Expression {}
-	
-	enum ParameterModifiers { In }
-	enum QueryExpressionPartitionType { }
-	
-	class ParameterDeclarationExpression : Expression {
-		List<AttributeSection> attributes;
-		[QuestionMarkDefault]
-		string         parameterName;
-		TypeReference  typeReference;
-		ParameterModifiers  paramModifier;
-		Expression     defaultValue;
-		
-		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName) {}
-		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParameterModifiers paramModifier) {}
-		public ParameterDeclarationExpression(TypeReference typeReference, string parameterName, ParameterModifiers paramModifier, Expression defaultValue) {}
-	}
-	
-	class NamedArgumentExpression : Expression {
-		string     name;
-		Expression expression;
-		
-		public NamedArgumentExpression() { }
-		public NamedArgumentExpression(string name, Expression expression) {}
-	}
-	
-	class MemberInitializerExpression : Expression {
-		string     name;
-		bool       isKey;
-		Expression expression;
-		
-		public MemberInitializerExpression() { }
-		public MemberInitializerExpression(string name, Expression expression) {}
-	}
-	
-	[IncludeBoolProperty("IsAnonymousType", "return createType.IsNull || string.IsNullOrEmpty(createType.Type);")]
-	class ObjectCreateExpression : Expression {
-		TypeReference    createType;
-		List<Expression> parameters;
-		CollectionInitializerExpression objectInitializer;
-		
-		public ObjectCreateExpression(TypeReference createType, List<Expression> parameters) {}
-	}
-	
-	[IncludeBoolProperty("IsImplicitlyTyped", "return createType.IsNull || string.IsNullOrEmpty(createType.Type);")]
-	class ArrayCreateExpression : Expression {
-		TypeReference              createType;
-		List<Expression>           arguments;
-		CollectionInitializerExpression arrayInitializer;
-		
-		public ArrayCreateExpression(TypeReference createType) {}
-		public ArrayCreateExpression(TypeReference createType, List<Expression> arguments) {}
-		public ArrayCreateExpression(TypeReference createType, CollectionInitializerExpression arrayInitializer) {}
-	}
-	
-	[ImplementNullable(NullableImplementation.Shadow)]
-	class CollectionInitializerExpression : Expression {
-		List<Expression> createExpressions;
-		
-		public CollectionInitializerExpression() {}
-		public CollectionInitializerExpression(List<Expression> createExpressions) {}
-	}
-	
-	enum AssignmentOperatorType {}
-	
-	class AssignmentExpression : Expression {
-		Expression             left;
-		AssignmentOperatorType op;
-		Expression             right;
-		
-		public AssignmentExpression(Expression left, AssignmentOperatorType op, Expression right) {}
-	}
-	
-	class BaseReferenceExpression : Expression {}
-	
-	enum BinaryOperatorType {}
-	
-	class BinaryOperatorExpression : Expression
-	{
-		Expression         left;
-		BinaryOperatorType op;
-		Expression         right;
-		
-		public BinaryOperatorExpression() { }
-		public BinaryOperatorExpression(Expression left, BinaryOperatorType op, Expression right) {}
-	}
-	
-	enum CastType {}
-	
-	class CastExpression : Expression
-	{
-		TypeReference castTo;
-		Expression    expression;
-		CastType      castType;
-		
-		public CastExpression(TypeReference castTo) {}
-		public CastExpression(TypeReference castTo, Expression expression, CastType castType) {}
-	}
-	
-	class MemberReferenceExpression : Expression
-	{
-		Expression targetObject;
-		string     memberName;
-		List<TypeReference> typeArguments;
-		
-		public MemberReferenceExpression(Expression targetObject, string memberName) {}
-	}
-	
-	class IdentifierExpression : Expression {
-		string identifier;
-		List<TypeReference> typeArguments;
-		
-		public IdentifierExpression(string identifier) {}
-	}
-	
-	class InvocationExpression : Expression {
-		Expression          targetObject;
-		List<Expression>    arguments;
-		
-		public InvocationExpression(Expression targetObject) {}
-		public InvocationExpression(Expression targetObject, List<Expression> arguments) {}
-	}
-	
-	class ParenthesizedExpression : Expression {
-		Expression expression;
-		
-		public ParenthesizedExpression(Expression expression) {}
-	}
-	
-	class ThisReferenceExpression : Expression {}
-	
-	class TypeOfExpression : Expression {
-		TypeReference typeReference;
-		
-		public TypeOfExpression(TypeReference typeReference) {}
-	}
-	
-	class TypeReferenceExpression : Expression {
-		TypeReference typeReference;
-		
-		public TypeReferenceExpression(TypeReference typeReference) {}
-	}
-	
-	enum UnaryOperatorType {}
-	
-	class UnaryOperatorExpression : Expression {
-		UnaryOperatorType op;
-		Expression        expression;
-		
-		public UnaryOperatorExpression(UnaryOperatorType op) {}
-		public UnaryOperatorExpression(Expression expression, UnaryOperatorType op) {}
-	}
-	
-	[IncludeMember("public Location ExtendedEndLocation { get; set; }")]
-	class LambdaExpression : Expression {
-		List<ParameterDeclarationExpression> parameters;
-		Statement statementBody;
-		Expression expressionBody;
-		TypeReference returnType;
-	}
-	
-	class ConditionalExpression : Expression {
-		Expression condition;
-		Expression trueExpression;
-		Expression falseExpression;
-		
-		public ConditionalExpression() { }
-		public ConditionalExpression(Expression condition, Expression trueExpression, Expression falseExpression) {}
-	}
-	
-	class DefaultValueExpression : Expression {
-		TypeReference typeReference;
-		
-		public DefaultValueExpression(TypeReference typeReference) {}
-	}
-	
-	enum FieldDirection {}
-	
-	class DirectionExpression : Expression {
-		FieldDirection fieldDirection;
-		Expression     expression;
-		
-		public DirectionExpression(FieldDirection fieldDirection, Expression expression) {}
-	}
-	
-	class AddressOfExpression : Expression {
-		Expression expression;
-		
-		public AddressOfExpression(Expression expression) {}
-	}
-	
-	class ClassReferenceExpression : Expression {}
-	
-	class TypeOfIsExpression : Expression {
-		Expression    expression;
-		TypeReference typeReference;
-		
-		public TypeOfIsExpression(Expression expression, TypeReference typeReference) {}
-	}
-	
-	class QueryExpression : Expression {
-		List<QueryExpressionClause> clauses;
-	}
-	
-	[ImplementNullable]
-	abstract class QueryExpressionClause : AbstractNode, INullable { }
-	
-	class QueryExpressionWhereClause : QueryExpressionClause {
-		Expression condition;
-	}
-	
-	class QueryExpressionLetClause : QueryExpressionClause {
-		[QuestionMarkDefault]
-		string identifier;
-		Expression expression;
-	}
-	
-	[ImplementNullable(NullableImplementation.Shadow)]
-	class QueryExpressionFromClause : QueryExpressionClause {
-		List<CollectionRangeVariable> sources;
-	}
-
-	class QueryExpressionAggregateClause : 	QueryExpressionClause {
-		CollectionRangeVariable source;
-		List<QueryExpressionClause> middleClauses;
-		List<ExpressionRangeVariable> intoVariables;
-	}
-	
-	[ImplementNullable]
-	class ExpressionRangeVariable : AbstractNode, INullable {
-		string identifier;
-		Expression expression;
-		TypeReference type;
-	}
-	
-	[ImplementNullable]
-	class CollectionRangeVariable : AbstractNode, INullable {
-		string identifier;
-		Expression expression;
-		TypeReference type;
-	}
-	
-	class QueryExpressionJoinClause : QueryExpressionClause {
-		Expression onExpression;
-		Expression equalsExpression;
-		CollectionRangeVariable source;
-		
-		string intoIdentifier;
-	}
-	
-	[ImplementNullable(NullableImplementation.Shadow)]
-	class QueryExpressionJoinVBClause : QueryExpressionClause {
-		CollectionRangeVariable joinVariable;
-		QueryExpressionJoinVBClause subJoin;
-		List<QueryExpressionJoinConditionVB> conditions;
-	}
-
-	class QueryExpressionPartitionVBClause : QueryExpressionClause {
-		Expression expression;
-		QueryExpressionPartitionType partitionType;
-	}
-	
-	class QueryExpressionJoinConditionVB : AbstractNode {
-		Expression leftSide;
-		Expression rightSide;
-	}
-	
-	class QueryExpressionOrderClause : QueryExpressionClause {
-		List<QueryExpressionOrdering> orderings;
-	}
-	
-	class QueryExpressionOrdering : AbstractNode {
-		Expression criteria;
-		QueryExpressionOrderingDirection direction;
-	}
-	
-	enum QueryExpressionOrderingDirection {
-		None, Ascending, Descending
-	}
-	
-	class QueryExpressionSelectClause : QueryExpressionClause {
-		Expression projection;
-	}
-
-	class QueryExpressionSelectVBClause : QueryExpressionClause {
-		List<ExpressionRangeVariable> variables;
-	}
-	
-	class QueryExpressionLetVBClause : QueryExpressionClause {
-		List<ExpressionRangeVariable> variables;
-	}
-	
-	class QueryExpressionDistinctClause : QueryExpressionClause {
-		
-	}
-	
-	class QueryExpressionGroupClause : QueryExpressionClause {
-		Expression projection;
-		Expression groupBy;
-	}
-	
-	class QueryExpressionGroupVBClause : QueryExpressionClause  {
-		List<ExpressionRangeVariable> groupVariables;
-		List<ExpressionRangeVariable> byVariables;
-		List<ExpressionRangeVariable> intoVariables;
-	}
-	
-	class QueryExpressionGroupJoinVBClause : QueryExpressionClause {
-		QueryExpressionJoinVBClause joinClause;
-		List<ExpressionRangeVariable> intoVariables;
-	}
-	
-	enum XmlAxisType { }
-	
-	class XmlMemberAccessExpression : Expression {
-		Expression targetObject;
-		XmlAxisType axisType;
-		bool isXmlIdentifier;
-		string identifier;
-		
-		public XmlMemberAccessExpression(Expression targetObject, XmlAxisType axisType, string identifier, bool isXmlIdentifier) {}
-	}
-
-	abstract class XmlExpression : Expression { }
-
-	class XmlDocumentExpression : XmlExpression {
-		List<XmlExpression> expressions;
-	}
-	
-	enum XmlContentType { }
-	
-	class XmlContentExpression : XmlExpression {
-		string content;
-		XmlContentType type;
-		
-		public XmlContentExpression(string content, XmlContentType type) {}
-	}
-	
-	class XmlEmbeddedExpression : XmlExpression {
-		Expression inlineVBExpression;
-	}
-
-	[IncludeBoolProperty("IsExpression", "return !content.IsNull;")]
-	[IncludeBoolProperty("NameIsExpression", "return !nameExpression.IsNull;")]
-	[HasChildren]
-	class XmlElementExpression : XmlExpression {
-		Expression content;
-		Expression nameExpression;
-		string xmlName;
-		List<XmlExpression> attributes;
-	}
-	
-	[IncludeBoolProperty("IsLiteralValue", "return expressionValue.IsNull;")]
-	class XmlAttributeExpression : XmlExpression {
-		string name;
-		string literalValue;
-		bool useDoubleQuotes;
-		Expression expressionValue;
-	}
-}
diff --git a/NRefactory/VBAstGenerator/Ast/GlobalLevel.cs b/NRefactory/VBAstGenerator/Ast/GlobalLevel.cs
deleted file mode 100644
index 64b4ec05c..000000000
--- a/NRefactory/VBAstGenerator/Ast/GlobalLevel.cs
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace VBAstGenerator.Ast
-{
-	[CustomImplementation, HasChildren]
-	class CompilationUnit : AbstractNode {}
-	
-	[HasChildren]
-	class NamespaceDeclaration : AbstractNode
-	{
-		string name;
-		
-		public NamespaceDeclaration(string name) {}
-	}
-	
-	enum VarianceModifier { Invariant, Covariant, Contravariant };
-	
-	class TemplateDefinition : AttributedNode
-	{
-		[QuestionMarkDefault]
-		string name;
-		VarianceModifier varianceModifier;
-		List<TypeReference> bases;
-		
-		public TemplateDefinition() {}
-		public TemplateDefinition(string name, List<AttributeSection> attributes) : base(attributes) {}
-	}
-	
-	class DelegateDeclaration : AttributedNode
-	{
-		[QuestionMarkDefault]
-		string          name;
-		TypeReference   returnType;
-		List<ParameterDeclarationExpression> parameters;
-		List<TemplateDefinition> templates;
-		
-		public DelegateDeclaration(Modifiers modifier, List<AttributeSection> attributes) : base(modifier, attributes) {}
-	}
-	
-	enum ClassType { Class }
-	
-	[HasChildren]
-	class TypeDeclaration : AttributedNode
-	{
-		// Children of Struct:    FieldDeclaration, MethodDeclaration, EventDeclaration, ConstructorDeclaration,
-		//                        OperatorDeclaration, TypeDeclaration, IndexerDeclaration, PropertyDeclaration, in VB: DeclareDeclaration
-		// Childrean of class:    children of struct, DestructorDeclaration
-		// Children of Interface: MethodDeclaration, PropertyDeclaration, IndexerDeclaration, EventDeclaration, in VB: TypeDeclaration(Enum) too
-		// Children of Enum:      FieldDeclaration
-		string name;
-		ClassType type;
-		List<TypeReference> baseTypes;
-		List<TemplateDefinition> templates;
-		Location bodyStartLocation;
-		
-		public TypeDeclaration(Modifiers modifier, List<AttributeSection> attributes) : base(modifier, attributes) {}
-	}
-	
-	[IncludeBoolProperty("IsAlias", "return !alias.IsNull;")]
-	[IncludeBoolProperty("IsXml", "return xmlPrefix != null;")]
-	class Using : AbstractNode
-	{
-		[QuestionMarkDefault]
-		string name;
-		TypeReference alias;
-		string xmlPrefix;
-		
-		public Using(string name) {}
-		public Using(string name, TypeReference alias) {}
-		public Using(string name, string xmlPrefix) {}
-	}
-	
-	[IncludeMember("public UsingDeclaration(string @namespace) : this(@namespace, TypeReference.Null) {}")]
-	[IncludeMember("public UsingDeclaration(string @namespace, TypeReference alias) {" +
-	               " usings = new List<Using>(1);" +
-	               " usings.Add(new Using(@namespace, alias)); " +
-	               "}")]
-	[IncludeMember("public UsingDeclaration(string xmlNamespace, string prefix) {" +
-	               " usings = new List<Using>(1);" +
-	               " usings.Add(new Using(xmlNamespace, prefix)); " +
-	               "}")]
-	class UsingDeclaration : AbstractNode
-	{
-		List<Using> usings;
-		
-		public UsingDeclaration(List<Using> usings) {}
-	}
-	
-	enum OptionType { None }
-	
-	class OptionDeclaration : AbstractNode
-	{
-		OptionType optionType;
-		bool       optionValue;
-		
-		public OptionDeclaration(OptionType optionType, bool optionValue) {}
-	}
-	
-	class ExternAliasDirective : AbstractNode
-	{
-		string name;
-	}
-}
diff --git a/NRefactory/VBAstGenerator/Ast/Node.cs b/NRefactory/VBAstGenerator/Ast/Node.cs
deleted file mode 100644
index c1cce36dc..000000000
--- a/NRefactory/VBAstGenerator/Ast/Node.cs
+++ /dev/null
@@ -1,68 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace VBAstGenerator.Ast
-{
-	interface INode {}
-	interface INullable {}
-	struct Location {}
-	
-	enum Modifiers { None }
-	
-	[CustomImplementation]
-	abstract class AbstractNode : INode {}
-	
-	abstract class AttributedNode : AbstractNode
-	{
-		List<AttributeSection> attributes;
-		Modifiers modifier;
-		
-		public AttributedNode() {}
-		public AttributedNode(List<AttributeSection> attributes) {}
-		public AttributedNode(Modifiers modifier, List<AttributeSection> attributes) {}
-	}
-	
-	abstract class ParametrizedNode : AttributedNode
-	{
-		string name;
-		List<ParameterDeclarationExpression> parameters;
-		
-		public ParametrizedNode() {}
-		
-		public ParametrizedNode(Modifiers modifier, List<AttributeSection> attributes,
-		                        string name, List<ParameterDeclarationExpression> parameters)
-			: base(modifier, attributes)
-		{}
-	}
-	
-	[CustomImplementation]
-	class TypeReference : AbstractNode, INullable
-	{
-		List<TypeReference> genericTypes;
-	}
-	
-	[CustomImplementation]
-	class InnerClassTypeReference : TypeReference
-	{
-		TypeReference baseType;
-	}
-	
-	class AttributeSection : AbstractNode, INullable
-	{
-		string attributeTarget;
-		List<Attribute> attributes;
-	}
-	
-	class Attribute : AbstractNode
-	{
-		string name;
-		List<Expression> positionalArguments;
-		List<NamedArgumentExpression> namedArguments;
-		
-		public Attribute() {}
-		public Attribute(string name, List<Expression> positionalArguments, List<NamedArgumentExpression> namedArguments) {}
-	}
-}
diff --git a/NRefactory/VBAstGenerator/Ast/Statements.cs b/NRefactory/VBAstGenerator/Ast/Statements.cs
deleted file mode 100644
index 482595443..000000000
--- a/NRefactory/VBAstGenerator/Ast/Statements.cs
+++ /dev/null
@@ -1,262 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace VBAstGenerator.Ast
-{
-	[CustomImplementation]
-	abstract class Statement : AbstractNode, INullable {}
-	
-	[CustomImplementation]
-	abstract class StatementWithEmbeddedStatement : Statement {
-		Statement embeddedStatement;
-	}
-	
-	[CustomImplementation, HasChildren]
-	class BlockStatement : Statement {}
-	
-	enum ContinueType {}
-	
-	class ContinueStatement : Statement {
-		ContinueType continueType;
-		
-		public ContinueStatement() {}
-		public ContinueStatement(ContinueType continueType) {}
-	}
-	
-	enum ConditionType {}
-	enum ConditionPosition {}
-	
-	class DoLoopStatement : StatementWithEmbeddedStatement {
-		Expression        condition;
-		ConditionType     conditionType;
-		ConditionPosition conditionPosition;
-		
-		public DoLoopStatement(Expression condition, Statement embeddedStatement, ConditionType conditionType, ConditionPosition conditionPosition) {}
-	}
-	
-	class ForeachStatement : StatementWithEmbeddedStatement {
-		TypeReference typeReference;
-		string        variableName;
-		Expression    expression;
-		Expression    nextExpression;
-		
-		public ForeachStatement(TypeReference typeReference, string variableName, Expression expression, Statement embeddedStatement) {}
-		public ForeachStatement(TypeReference typeReference, string variableName, Expression expression, Statement embeddedStatement, Expression nextExpression) {}
-	}
-	
-	class GotoStatement : Statement {
-		string label;
-		
-		public GotoStatement(string label) {}
-	}
-	
-	[IncludeMember(@"
-			public IfElseStatement(Expression condition, Statement trueStatement)
-				: this(condition) {
-				this.trueStatement.Add(Statement.CheckNull(trueStatement));
-				if (trueStatement != null) trueStatement.Parent = this;
-			}")]
-	[IncludeMember(@"
-			public IfElseStatement(Expression condition, Statement trueStatement, Statement falseStatement)
-				: this(condition) {
-				this.trueStatement.Add(Statement.CheckNull(trueStatement));
-				this.falseStatement.Add(Statement.CheckNull(falseStatement));
-				if (trueStatement != null) trueStatement.Parent = this;
-				if (falseStatement != null) falseStatement.Parent = this;
-			}")]
-	[IncludeBoolProperty("HasElseStatements", "return falseStatement.Count > 0;")]
-	[IncludeBoolProperty("HasElseIfSections", "return elseIfSections.Count > 0;")]
-	class IfElseStatement : Statement {
-		Expression condition;
-		List<Statement> trueStatement; // List for stmt : stmt : stmt ... in VB.NET
-		List<Statement> falseStatement;
-		List<ElseIfSection> elseIfSections;
-		
-		public IfElseStatement(Expression condition) {}
-	}
-	
-	class ElseIfSection : StatementWithEmbeddedStatement {
-		Expression condition;
-		
-		public ElseIfSection(Expression condition, Statement embeddedStatement) {}
-	}
-	
-	class LabelStatement : Statement {
-		string label;
-		
-		public LabelStatement(string label) {}
-	}
-	
-	[CustomImplementation]
-	class LocalVariableDeclaration : Statement {
-		TypeReference             typeReference;
-		Modifiers                  modifier;
-		List<VariableDeclaration> variables;
-	}
-	
-	class LockStatement : StatementWithEmbeddedStatement
-	{
-		Expression lockExpression;
-		
-		public LockStatement(Expression lockExpression, Statement embeddedStatement) {}
-	}
-	
-	class ReturnStatement : Statement
-	{
-		Expression expression;
-		
-		public ReturnStatement(Expression expression) { }
-	}
-	
-	class ExpressionStatement : Statement {
-		Expression expression;
-		
-		public ExpressionStatement(Expression expression) {}
-	}
-	
-	class SwitchStatement : Statement {
-		Expression          switchExpression;
-		List<SwitchSection> switchSections;
-		
-		public SwitchStatement(Expression switchExpression, List<SwitchSection> switchSections) {}
-	}
-	
-	class SwitchSection : BlockStatement {
-		List<CaseLabel> switchLabels;
-		
-		public SwitchSection() { }
-		public SwitchSection(List<CaseLabel> switchLabels) { }
-	}
-	
-	[IncludeBoolProperty("IsDefault", "return label.IsNull;")]
-	class CaseLabel : AbstractNode {
-		Expression         label;
-		BinaryOperatorType binaryOperatorType;
-		Expression         toExpression;
-		
-		public CaseLabel() {}
-		public CaseLabel(Expression label) {}
-		public CaseLabel(Expression label, Expression toExpression) {}
-		public CaseLabel(BinaryOperatorType binaryOperatorType, Expression label) {}
-	}
-	
-	class ThrowStatement : Statement {
-		Expression expression;
-		
-		public ThrowStatement(Expression expression) {}
-	}
-	
-	class TryCatchStatement : Statement {
-		Statement         statementBlock;
-		List<CatchClause> catchClauses;
-		Statement         finallyBlock;
-		
-		public TryCatchStatement(Statement statementBlock, List<CatchClause> catchClauses, Statement finallyBlock) {}
-	}
-	
-	class CatchClause : AbstractNode {
-		TypeReference typeReference;
-		string     variableName;
-		Statement  statementBlock;
-		Expression condition;
-		
-		public CatchClause(TypeReference typeReference, string variableName, Statement statementBlock) {}
-		public CatchClause(TypeReference typeReference, string variableName, Statement statementBlock, Expression condition) {}
-		public CatchClause(Statement statementBlock) {}
-	}
-	
-	class UsingStatement : StatementWithEmbeddedStatement {
-		Statement resourceAcquisition;
-		
-		public UsingStatement(Statement resourceAcquisition, Statement embeddedStatement) {}
-	}
-	
-	class AddHandlerStatement : Statement {
-		Expression eventExpression;
-		Expression handlerExpression;
-		
-		public AddHandlerStatement(Expression eventExpression, Expression handlerExpression) {}
-	}
-	
-	class EndStatement : Statement {}
-	
-	class EraseStatement : Statement {
-		List<Expression> expressions;
-		
-		public EraseStatement() {}
-		public EraseStatement(List<Expression> expressions) {}
-	}
-	
-	class ErrorStatement : Statement {
-		Expression expression;
-		
-		public ErrorStatement(Expression expression) {}
-	}
-	
-	enum ExitType {}
-	
-	class ExitStatement : Statement {
-		ExitType exitType;
-		
-		public ExitStatement(ExitType exitType) {}
-	}
-	
-	class ForNextStatement : StatementWithEmbeddedStatement {
-		Expression start;
-		Expression end;
-		Expression step;
-		
-		List<Expression> nextExpressions;
-		// either use typeReference+variableName
-		TypeReference typeReference;
-		string        variableName;
-		// or use loopVariableExpression:
-		Expression loopVariableExpression;
-	}
-	
-	class OnErrorStatement : StatementWithEmbeddedStatement {
-		public OnErrorStatement(Statement embeddedStatement) {}
-	}
-	
-	class RaiseEventStatement : Statement {
-		string eventName;
-		List<Expression> arguments;
-		
-		public RaiseEventStatement(string eventName, List<Expression> arguments) {}
-	}
-	
-	class ReDimStatement : Statement {
-		List<InvocationExpression> reDimClauses;
-		bool isPreserve;
-		
-		public ReDimStatement(bool isPreserve) {}
-	}
-	
-	class RemoveHandlerStatement : Statement {
-		Expression eventExpression;
-		Expression handlerExpression;
-		
-		public RemoveHandlerStatement(Expression eventExpression, Expression handlerExpression) {}
-	}
-	
-	class ResumeStatement : Statement {
-		string labelName;
-		bool isResumeNext;
-		
-		public ResumeStatement(bool isResumeNext) {}
-		
-		public ResumeStatement(string labelName) {}
-	}
-	
-	class StopStatement : Statement {}
-	
-	class WithStatement : Statement {
-		Expression     expression;
-		BlockStatement body;
-		
-		public WithStatement(Expression expression) {}
-	}
-}
diff --git a/NRefactory/VBAstGenerator/Ast/TypeLevel.cs b/NRefactory/VBAstGenerator/Ast/TypeLevel.cs
deleted file mode 100644
index 47814c293..000000000
--- a/NRefactory/VBAstGenerator/Ast/TypeLevel.cs
+++ /dev/null
@@ -1,227 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-
-namespace VBAstGenerator.Ast
-{
-	class VariableDeclaration : AbstractNode
-	{
-		string     name;
-		Expression initializer;
-		TypeReference typeReference;
-		Expression fixedArrayInitialization;
-		
-		public VariableDeclaration(string name) {}
-		public VariableDeclaration(string name, Expression initializer) {}
-		public VariableDeclaration(string name, Expression initializer, TypeReference typeReference) {}
-	}
-	
-	class ConstructorDeclaration : ParametrizedNode
-	{
-		ConstructorInitializer constructorInitializer;
-		BlockStatement         body;
-		
-		public ConstructorDeclaration(string name, Modifiers modifier,
-		                              List<ParameterDeclarationExpression> parameters,
-		                              List<AttributeSection> attributes)
-			: base(modifier, attributes, name, parameters)
-		{}
-		
-		public ConstructorDeclaration(string name, Modifiers modifier,
-		                              List<ParameterDeclarationExpression> parameters,
-		                              ConstructorInitializer constructorInitializer,
-		                              List<AttributeSection> attributes)
-			: base(modifier, attributes, name, parameters)
-		{}
-	}
-	
-	enum ConstructorInitializerType { None }
-	
-	[ImplementNullable]
-	class ConstructorInitializer : AbstractNode, INullable
-	{
-		ConstructorInitializerType constructorInitializerType;
-		List<Expression>           arguments;
-	}
-	
-	[ImplementNullable(NullableImplementation.Abstract)]
-	abstract class EventAddRemoveRegion : AttributedNode, INullable
-	{
-		BlockStatement block;
-		List<ParameterDeclarationExpression> parameters;
-		
-		public EventAddRemoveRegion(List<AttributeSection> attributes) : base(attributes) {}
-	}
-	
-	[ImplementNullable(NullableImplementation.CompleteAbstract)]
-	class EventAddRegion : EventAddRemoveRegion
-	{
-		public EventAddRegion(List<AttributeSection> attributes) : base(attributes) {}
-	}
-	
-	[ImplementNullable(NullableImplementation.CompleteAbstract)]
-	class EventRemoveRegion : EventAddRemoveRegion
-	{
-		public EventRemoveRegion(List<AttributeSection> attributes) : base(attributes) {}
-	}
-	
-	[ImplementNullable(NullableImplementation.CompleteAbstract)]
-	class EventRaiseRegion : EventAddRemoveRegion
-	{
-		public EventRaiseRegion(List<AttributeSection> attributes) : base(attributes) {}
-	}
-	
-	class InterfaceImplementation : AbstractNode
-	{
-		TypeReference interfaceType;
-		[QuestionMarkDefault]
-		string memberName;
-		
-		public InterfaceImplementation(TypeReference interfaceType, string memberName) {}
-	}
-	
-	[IncludeBoolProperty("HasAddRegion",    "return !addRegion.IsNull;")]
-	[IncludeBoolProperty("HasRemoveRegion", "return !removeRegion.IsNull;")]
-	[IncludeBoolProperty("HasRaiseRegion",  "return !raiseRegion.IsNull;")]
-	class EventDeclaration : MemberNode
-	{
-		EventAddRegion addRegion;
-		EventRemoveRegion removeRegion;
-		EventRaiseRegion raiseRegion;
-		Location bodyStart;
-		Location bodyEnd;
-		Expression initializer;
-	}
-	
-	[IncludeMember(@"
-		public TypeReference GetTypeForField(int fieldIndex)
-		{
-			if (!typeReference.IsNull) {
-				return typeReference;
-			}
-			return ((VariableDeclaration)Fields[fieldIndex]).TypeReference;
-		}")]
-	[IncludeMember(@"
-		public VariableDeclaration GetVariableDeclaration(string variableName)
-		{
-			foreach (VariableDeclaration variableDeclaration in Fields) {
-				if (variableDeclaration.Name == variableName) {
-					return variableDeclaration;
-				}
-			}
-			return null;
-		}")]
-	class FieldDeclaration : AttributedNode
-	{
-		TypeReference             typeReference;
-		List<VariableDeclaration> fields;
-		
-		// for enum members
-		public FieldDeclaration(List<AttributeSection> attributes) : base(attributes) {}
-		
-		// for all other cases
-		public FieldDeclaration(List<AttributeSection> attributes, TypeReference typeReference, Modifiers modifier)
-			: base(modifier, attributes)
-		{}
-	}
-	
-	abstract class MemberNode : ParametrizedNode
-	{
-		List<InterfaceImplementation> interfaceImplementations;
-		TypeReference typeReference;
-		
-		public MemberNode() {}
-		
-		public MemberNode(Modifiers modifier, List<AttributeSection> attributes,
-		                  string name, List<ParameterDeclarationExpression> parameters)
-			: base(modifier, attributes, name, parameters)
-		{}
-	}
-	
-	class MethodDeclaration : MemberNode
-	{
-		BlockStatement   body;
-		List<string>     handlesClause;
-		List<TemplateDefinition> templates;
-		bool isExtensionMethod;
-	}
-	
-	enum ConversionType { None }
-	enum OverloadableOperatorType { None }
-	
-	[IncludeBoolProperty("IsConversionOperator", "return conversionType != ConversionType.None;")]
-	class OperatorDeclaration : MethodDeclaration
-	{
-		ConversionType conversionType;
-		OverloadableOperatorType overloadableOperator;
-	}
-	
-	[IncludeBoolProperty("HasGetRegion", "return !getRegion.IsNull;")]
-	[IncludeBoolProperty("HasSetRegion", "return !setRegion.IsNull;")]
-	[IncludeBoolProperty("IsReadOnly", "return HasGetRegion && !HasSetRegion;")]
-	[IncludeBoolProperty("IsWriteOnly", "return !HasGetRegion && HasSetRegion;")]
-	[IncludeBoolProperty("IsIndexer", "return (Modifier & Modifiers.Default) != 0;")]
-	[IncludeMember(@"
-		internal PropertyDeclaration(string name, TypeReference typeReference, Modifiers modifier, List<AttributeSection> attributes) : this(modifier, attributes, name, null)
-		{
-			this.TypeReference = typeReference;
-			if ((modifier & Modifiers.ReadOnly) != Modifiers.ReadOnly) {
-				this.SetRegion = new PropertySetRegion(null, null);
-			}
-			if ((modifier & Modifiers.WriteOnly) != Modifiers.WriteOnly) {
-				this.GetRegion = new PropertyGetRegion(null, null);
-			}
-		}")]
-	class PropertyDeclaration : MemberNode
-	{
-		Location          bodyStart;
-		Location          bodyEnd;
-		PropertyGetRegion getRegion;
-		PropertySetRegion setRegion;
-		Expression        initializer;
-		
-		public PropertyDeclaration(Modifiers modifier, List<AttributeSection> attributes,
-		                           string name, List<ParameterDeclarationExpression> parameters)
-			: base(modifier, attributes, name, parameters)
-		{}
-	}
-	
-	[ImplementNullable(NullableImplementation.Abstract)]
-	abstract class PropertyGetSetRegion : AttributedNode, INullable
-	{
-		// can be null if only the definition is there (interface declaration)
-		BlockStatement block;
-		
-		public PropertyGetSetRegion(BlockStatement block, List<AttributeSection> attributes) : base(attributes) {}
-	}
-	
-	[ImplementNullable(NullableImplementation.CompleteAbstract)]
-	class PropertyGetRegion : PropertyGetSetRegion
-	{
-		public PropertyGetRegion(BlockStatement block, List<AttributeSection> attributes) : base(block, attributes) {}
-	}
-	
-	[ImplementNullable(NullableImplementation.CompleteAbstract)]
-	class PropertySetRegion : PropertyGetSetRegion
-	{
-		List<ParameterDeclarationExpression> parameters;
-		
-		public PropertySetRegion(BlockStatement block, List<AttributeSection> attributes) : base(block, attributes) {}
-	}
-	
-	enum CharsetModifier { None }
-	
-	class DeclareDeclaration : ParametrizedNode
-	{
-		string          alias;
-		string          library;
-		CharsetModifier charset;
-		TypeReference   typeReference;
-		
-		public DeclareDeclaration(string name, Modifiers modifier, TypeReference typeReference, List<ParameterDeclarationExpression> parameters, List<AttributeSection> attributes, string library, string alias, CharsetModifier charset)
-			: base(modifier, attributes, name, parameters)
-		{}
-	}
-}
diff --git a/NRefactory/VBAstGenerator/Attributes.cs b/NRefactory/VBAstGenerator/Attributes.cs
deleted file mode 100644
index 9a655ccda..000000000
--- a/NRefactory/VBAstGenerator/Attributes.cs
+++ /dev/null
@@ -1,176 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.CodeDom;
-using System.Reflection;
-using ICSharpCode.EasyCodeDom;
-
-namespace VBAstGenerator
-{
-	public enum NullableImplementation
-	{
-		/// <summary>
-		/// Implement INullable with a virtual bool IsNull, create Null class and static instance
-		/// of it.
-		/// </summary>
-		Default,
-		/// <summary>
-		/// Create Null class and a static instance using the "new" modifier.
-		/// </summary>
-		Shadow,
-		/// <summary>
-		/// Implement INullable with a virtual bool IsNull.
-		/// </summary>
-		Abstract,
-		/// <summary>
-		/// Complete an abstract nullable implementation by creating the Null class
-		/// and the static instance.
-		/// </summary>
-		CompleteAbstract
-	}
-	
-	public abstract class TypeImplementationModifierAttribute : Attribute
-	{
-		public abstract void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type);
-	}
-	
-	[AttributeUsage(AttributeTargets.Class)]
-	public class CustomImplementationAttribute : Attribute
-	{
-	}
-	
-	[AttributeUsage(AttributeTargets.Class)]
-	public class HasChildrenAttribute : Attribute
-	{
-	}
-	
-	[AttributeUsage(AttributeTargets.Field)]
-	public class QuestionMarkDefaultAttribute : Attribute
-	{
-	}
-	
-	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
-	public class IncludeMemberAttribute : TypeImplementationModifierAttribute
-	{
-		string code;
-		
-		public IncludeMemberAttribute(string code)
-		{
-			this.code = code;
-		}
-		
-		public override void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type)
-		{
-			ctd.Members.Add(new CodeSnippetTypeMember(code));
-		}
-	}
-	
-	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
-	public class IncludeBoolPropertyAttribute : TypeImplementationModifierAttribute
-	{
-		string name;
-		string code;
-		
-		public IncludeBoolPropertyAttribute(string name, string code)
-		{
-			this.name = name;
-			this.code = code;
-		}
-		
-		public override void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type)
-		{
-			CodeMemberProperty prop = new CodeMemberProperty();
-			prop.Name = name;
-			prop.Type = new CodeTypeReference(typeof(bool));
-			prop.Attributes = MemberAttributes.Public | MemberAttributes.Final;
-			prop.GetStatements.Add(new CodeSnippetStatement("\t\t\t\t" + code));
-			ctd.Members.Add(prop);
-		}
-	}
-	
-	[AttributeUsage(AttributeTargets.Class)]
-	public class ImplementNullableAttribute : TypeImplementationModifierAttribute
-	{
-		NullableImplementation implementation;
-		
-		public ImplementNullableAttribute()
-		{
-			this.implementation = NullableImplementation.Default;
-		}
-		
-		public ImplementNullableAttribute(NullableImplementation implementation)
-		{
-			this.implementation = implementation;
-		}
-		
-		public override void ModifyImplementation(CodeNamespace cns, CodeTypeDeclaration ctd, Type type)
-		{
-			if (implementation == NullableImplementation.Default || implementation == NullableImplementation.Abstract) {
-				ctd.BaseTypes.Add(new CodeTypeReference("INullable"));
-				CodeMemberProperty prop = new CodeMemberProperty();
-				prop.Name = "IsNull";
-				prop.Type = new CodeTypeReference(typeof(bool));
-				prop.Attributes = MemberAttributes.Public;
-				prop.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(false)));
-				ctd.Members.Add(prop);
-			}
-			if (implementation != NullableImplementation.Abstract) {
-				CodeTypeDeclaration newType = new CodeTypeDeclaration("Null" + ctd.Name);
-				newType.TypeAttributes = TypeAttributes.Class | TypeAttributes.NotPublic | TypeAttributes.Sealed;
-				newType.BaseTypes.Add(new CodeTypeReference(ctd.Name));
-				cns.Types.Add(newType);
-				
-				System.Reflection.ConstructorInfo baseCtor = MainClass.GetBaseCtor(type);
-				if (baseCtor != null) {
-					CodeConstructor ctor = new CodeConstructor();
-					ctor.Attributes = MemberAttributes.Private;
-					foreach (object o in baseCtor.GetParameters()) {
-						ctor.BaseConstructorArgs.Add(new CodePrimitiveExpression(null));
-					}
-					newType.Members.Add(ctor);
-				}
-				
-				CodeMemberField field = new CodeMemberField(newType.Name, "Instance");
-				field.Attributes = MemberAttributes.Static | MemberAttributes.Assembly;
-				field.InitExpression = new CodeObjectCreateExpression(new CodeTypeReference(newType.Name));
-				newType.Members.Add(field);
-				
-				CodeMemberProperty prop = new CodeMemberProperty();
-				prop.Name = "IsNull";
-				prop.Type = new CodeTypeReference(typeof(bool));
-				prop.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-				prop.GetStatements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(true)));
-				newType.Members.Add(prop);
-				
-				CodeMemberMethod method = new CodeMemberMethod();
-				method.Name = "AcceptVisitor";
-				method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-				method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
-				method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
-				method.ReturnType = new CodeTypeReference(typeof(object));
-				method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(null)));
-				newType.Members.Add(method);
-				
-				method = new CodeMemberMethod();
-				method.Name = "ToString";
-				method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-				method.ReturnType = new CodeTypeReference(typeof(string));
-				method.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression("[" + newType.Name + "]")));
-				newType.Members.Add(method);
-				
-				prop = new CodeMemberProperty();
-				prop.Name = "Null";
-				prop.Type = new CodeTypeReference(ctd.Name);
-				prop.Attributes = MemberAttributes.Public | MemberAttributes.Static;
-				if (implementation == NullableImplementation.Shadow) {
-					prop.Attributes |= MemberAttributes.New;
-				}
-				CodeExpression ex = new CodeTypeReferenceExpression(newType.Name);
-				ex = new CodePropertyReferenceExpression(ex, "Instance");
-				prop.GetStatements.Add(new CodeMethodReturnStatement(ex));
-				ctd.Members.Add(prop);
-			}
-		}
-	}
-}
diff --git a/NRefactory/VBAstGenerator/EasyCodeDom.cs b/NRefactory/VBAstGenerator/EasyCodeDom.cs
deleted file mode 100644
index fcdaedbd0..000000000
--- a/NRefactory/VBAstGenerator/EasyCodeDom.cs
+++ /dev/null
@@ -1,382 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.CodeDom;
-
-namespace ICSharpCode.EasyCodeDom
-{
-	public static class Easy
-	{
-		public static CodeTypeReference TypeRef(Type type)
-		{
-			return new CodeTypeReference(type, CodeTypeReferenceOptions.GlobalReference);
-		}
-		public static CodeTypeReference TypeRef(CodeTypeDeclaration type)
-		{
-			return new CodeTypeReference(type.Name);
-		}
-		public static CodeTypeReference TypeRef(string typeName, params string[] typeArguments)
-		{
-			CodeTypeReference tr = new CodeTypeReference(typeName);
-			foreach (string ta in typeArguments) {
-				tr.TypeArguments.Add(ta);
-			}
-			return tr;
-		}
-		
-		/// <summary>
-		/// Gets the CodeExpression for any primitive value that can be expressed as literal.
-		/// Also works for enumeration values.
-		/// </summary>
-		public static CodeExpression Prim(object literalValue)
-		{
-			if (literalValue is Enum) {
-				return Type(literalValue.GetType()).Field(literalValue.ToString());
-			} else {
-				return new CodePrimitiveExpression(literalValue);
-			}
-		}
-		
-		public static CodeTypeReferenceExpression Type(Type type)
-		{
-			return Type(TypeRef(type));
-		}
-		public static CodeTypeReferenceExpression Type(CodeTypeReference type)
-		{
-			return new CodeTypeReferenceExpression(type);
-		}
-		public static CodeTypeReferenceExpression Type(string type)
-		{
-			return Type(new CodeTypeReference(type));
-		}
-		
-		public static CodeTypeOfExpression TypeOf(Type type)
-		{
-			return TypeOf(TypeRef(type));
-		}
-		public static CodeTypeOfExpression TypeOf(CodeTypeReference type)
-		{
-			return new CodeTypeOfExpression(type);
-		}
-		
-		public static CodeObjectCreateExpression New(Type type, params CodeExpression[] arguments)
-		{
-			return New(TypeRef(type), arguments);
-		}
-		public static CodeObjectCreateExpression New(CodeTypeReference type, params CodeExpression[] arguments)
-		{
-			return new CodeObjectCreateExpression(type, arguments);
-		}
-		
-		public static CodeVariableReferenceExpression Var(string name)
-		{
-			return new CodeVariableReferenceExpression(name);
-		}
-		
-		public static CodeBinaryOperatorExpression Binary(CodeExpression left,
-		                                                  CodeBinaryOperatorType op,
-		                                                  CodeExpression right)
-		{
-			return new CodeBinaryOperatorExpression(left, op, right);
-		}
-		
-		public static CodeThisReferenceExpression This {
-			get {
-				return new CodeThisReferenceExpression();
-			}
-		}
-		
-		public static CodeBaseReferenceExpression Base {
-			get {
-				return new CodeBaseReferenceExpression();
-			}
-		}
-		
-		public static CodePropertySetValueReferenceExpression Value {
-			get {
-				return new CodePropertySetValueReferenceExpression();
-			}
-		}
-		
-		public static CodePrimitiveExpression Null {
-			get {
-				return new CodePrimitiveExpression(null);
-			}
-		}
-		
-		public static void AddSummary(CodeTypeMember member, string summary)
-		{
-			member.Comments.Add(new CodeCommentStatement("<summary>", true));
-			member.Comments.Add(new CodeCommentStatement(summary, true));
-			member.Comments.Add(new CodeCommentStatement("</summary>", true));
-		}
-		
-		internal static CodeAttributeDeclaration AddAttribute(CodeAttributeDeclarationCollection col,
-		                                                      CodeTypeReference type,
-		                                                      CodeExpression[] arguments)
-		{
-			CodeAttributeArgument[] attributeArguments = new CodeAttributeArgument[arguments.Length];
-			for (int i = 0; i < arguments.Length; i++) {
-				attributeArguments[i] = new CodeAttributeArgument(arguments[i]);
-			}
-			CodeAttributeDeclaration cad = new CodeAttributeDeclaration(type, attributeArguments);
-			col.Add(cad);
-			return cad;
-		}
-	}
-	
-	public static class ExtensionMethods
-	{
-		public static CodeMethodInvokeExpression InvokeMethod(this CodeExpression expr, string name, params CodeExpression[] arguments)
-		{
-			return new CodeMethodInvokeExpression(expr, name, arguments);
-		}
-		
-		public static CodeCastExpression CastTo(this CodeExpression expr, Type type)
-		{
-			return expr.CastTo(Easy.TypeRef(type));
-		}
-		public static CodeCastExpression CastTo(this CodeExpression expr, CodeTypeReference type)
-		{
-			return new CodeCastExpression(type, expr);
-		}
-		
-		public static CodeIndexerExpression Index(this CodeExpression expr, params CodeExpression[] indices)
-		{
-			return new CodeIndexerExpression(expr, indices);
-		}
-		
-		public static CodeFieldReferenceExpression Field(this CodeExpression expr, string name)
-		{
-			return new CodeFieldReferenceExpression(expr, name);
-		}
-		
-		public static CodePropertyReferenceExpression Property(this CodeExpression expr, string name)
-		{
-			return new CodePropertyReferenceExpression(expr, name);
-		}
-		
-		public static CodeNamespace AddNamespace(this CodeCompileUnit ccu, string name)
-		{
-			CodeNamespace n = new CodeNamespace(name);
-			ccu.Namespaces.Add(n);
-			return n;
-		}
-		
-		public static CodeTypeDeclaration AddType(this CodeNamespace ns, string name)
-		{
-			CodeTypeDeclaration n = new CodeTypeDeclaration(name);
-			ns.Types.Add(n);
-			return n;
-		}
-		
-		public static CodeNamespaceImport AddImport(this CodeNamespace ns, string nameSpace)
-		{
-			CodeNamespaceImport cni = new CodeNamespaceImport(nameSpace);
-			ns.Imports.Add(cni);
-			return cni;
-		}
-		
-		public static CodeMemberField AddField(this CodeTypeDeclaration typeDecl, Type type, string name)
-		{
-			return typeDecl.AddField(Easy.TypeRef(type), name);
-		}
-		public static CodeMemberField AddField(this CodeTypeDeclaration typeDecl, CodeTypeReference type, string name)
-		{
-			CodeMemberField f = new CodeMemberField(type, name);
-			typeDecl.Members.Add(f);
-			return f;
-		}
-		
-		public static EasyProperty AddProperty(this CodeTypeDeclaration typeDecl, Type type, string name)
-		{
-			return AddProperty(typeDecl, Easy.TypeRef(type), name);
-		}
-		public static EasyProperty AddProperty(this CodeTypeDeclaration typeDecl, CodeTypeReference type, string name)
-		{
-			EasyProperty p = new EasyProperty(type, name);
-			typeDecl.Members.Add(p);
-			if (typeDecl.IsInterface == false) {
-				p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
-			}
-			return p;
-		}
-		
-		public static EasyProperty AddProperty(this CodeTypeDeclaration typeDecl, CodeMemberField field, string name)
-		{
-			EasyProperty p = AddProperty(typeDecl, field.Type, name);
-			p.Getter.Return(new CodeVariableReferenceExpression(field.Name));
-			p.Attributes |= field.Attributes & MemberAttributes.Static; // copy static flag
-			return p;
-		}
-		
-		/// <summary>
-		/// Adds a method with return type <c>void</c> and attributes=Public|Final to this type.
-		/// </summary>
-		public static EasyMethod AddMethod(this CodeTypeDeclaration typeDecl, string name)
-		{
-			return AddMethod(typeDecl, Easy.TypeRef(typeof(void)), name);
-		}
-		/// <summary>
-		/// Adds a method with return type <paramref name="type"/> and attributes=Public|Final to this type.
-		/// </summary>
-		public static EasyMethod AddMethod(this CodeTypeDeclaration typeDecl, Type type, string name)
-		{
-			return AddMethod(typeDecl, Easy.TypeRef(type), name);
-		}
-		/// <summary>
-		/// Adds a method with return type <paramref name="type"/> and attributes=Public|Final to this type.
-		/// </summary>
-		public static EasyMethod AddMethod(this CodeTypeDeclaration typeDecl, CodeTypeReference type, string name)
-		{
-			EasyMethod p = new EasyMethod(type, name);
-			typeDecl.Members.Add(p);
-			if (typeDecl.IsInterface == false) {
-				p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
-			}
-			return p;
-		}
-		
-		public static CodeAttributeDeclaration AddAttribute(this CodeTypeMember typeMember, Type type, params CodeExpression[] arguments)
-		{
-			return Easy.AddAttribute(typeMember.CustomAttributes, Easy.TypeRef(type), arguments);
-		}
-		public static CodeAttributeDeclaration AddAttribute(this CodeTypeMember typeMember, CodeTypeReference type, params CodeExpression[] arguments)
-		{
-			return Easy.AddAttribute(typeMember.CustomAttributes, type, arguments);
-		}
-	}
-	
-	public class EasyProperty : CodeMemberProperty
-	{
-		EasyBlock getter, setter;
-		
-		public EasyProperty()
-		{
-			getter = new EasyBlock(this.GetStatements);
-			setter = new EasyBlock(this.SetStatements);
-		}
-		
-		public EasyProperty(CodeTypeReference type, string name) : this()
-		{
-			this.Type = type;
-			this.Name = name;
-		}
-		
-		public EasyBlock Getter {
-			get { return getter; }
-		}
-		
-		public EasyBlock Setter {
-			get { return setter; }
-		}
-	}
-	
-	public class EasyMethod : CodeMemberMethod
-	{
-		EasyBlock body;
-		
-		public EasyMethod()
-		{
-			body = new EasyBlock(this.Statements);
-		}
-		
-		public EasyMethod(CodeTypeReference type, string name) : this()
-		{
-			this.ReturnType = type;
-			this.Name = name;
-		}
-		
-		public CodeParameterDeclarationExpression AddParameter(Type type, string name)
-		{
-			return AddParameter(Easy.TypeRef(type), name);
-		}
-		public CodeParameterDeclarationExpression AddParameter(CodeTypeReference type, string name)
-		{
-			CodeParameterDeclarationExpression cpde;
-			cpde = new CodeParameterDeclarationExpression(type, name);
-			this.Parameters.Add(cpde);
-			return cpde;
-		}
-		
-		public EasyBlock Body {
-			get { return body; }
-		}
-	}
-	
-	public sealed class EasyBlock
-	{
-		readonly CodeStatementCollection csc;
-		
-		public EasyBlock(CodeStatementCollection csc)
-		{
-			this.csc = csc;
-		}
-		
-		public CodeMethodReturnStatement Return(CodeExpression expr)
-		{
-			CodeMethodReturnStatement st = new CodeMethodReturnStatement(expr);
-			csc.Add(st);
-			return st;
-		}
-		
-		public CodeThrowExceptionStatement Throw(CodeExpression expr)
-		{
-			CodeThrowExceptionStatement st = new CodeThrowExceptionStatement(expr);
-			csc.Add(st);
-			return st;
-		}
-		
-		public CodeAssignStatement Assign(CodeExpression lhs, CodeExpression rhs)
-		{
-			CodeAssignStatement st = new CodeAssignStatement(lhs, rhs);
-			csc.Add(st);
-			return st;
-		}
-		
-		/// <summary>
-		/// Execute one expression as statement.
-		/// </summary>
-		public CodeExpressionStatement Add(CodeExpression expr)
-		{
-			CodeExpressionStatement st = new CodeExpressionStatement(expr);
-			csc.Add(st);
-			return st;
-		}
-		
-		/// <summary>
-		/// Adds the statement.
-		/// </summary>
-		public CodeStatement Add(CodeStatement st)
-		{
-			csc.Add(st);
-			return st;
-		}
-		
-		/// <summary>
-		/// Invoke a method on target as statement.
-		/// </summary>
-		public CodeExpressionStatement InvokeMethod(CodeExpression target, string name, params CodeExpression[] arguments)
-		{
-			return Add(new CodeMethodInvokeExpression(target, name, arguments));
-		}
-		
-		/// <summary>
-		/// Declares a local variable.
-		/// </summary>
-		public CodeVariableDeclarationStatement DeclareVariable(Type type, string name)
-		{
-			return DeclareVariable(Easy.TypeRef(type), name);
-		}
-		/// <summary>
-		/// Declares a local variable.
-		/// </summary>
-		public CodeVariableDeclarationStatement DeclareVariable(CodeTypeReference type, string name)
-		{
-			CodeVariableDeclarationStatement st = new CodeVariableDeclarationStatement(type, name);
-			csc.Add(st);
-			return st;
-		}
-	}
-}
diff --git a/NRefactory/VBAstGenerator/KeywordGenerator.cs b/NRefactory/VBAstGenerator/KeywordGenerator.cs
deleted file mode 100644
index f1a0bc576..000000000
--- a/NRefactory/VBAstGenerator/KeywordGenerator.cs
+++ /dev/null
@@ -1,380 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.IO;
-using System.Linq;
-using System.Text;
-using System.Text.RegularExpressions;
-
-namespace VBAstGenerator
-{
-	static class KeywordGenerator
-	{
-		static readonly string baseDir = "../../../ICSharpCode.NRefactory.VB/Lexer/";
-		static readonly string testBaseDir = "../../../ICSharpCode.NRefactory.VB.Tests/Lexer/";
-		static readonly string parserBaseDir = "../../../ICSharpCode.NRefactory.VB/Parser/";
-		
-		public static void Generate()
-		{
-			try {
-				Dictionary<string, string> properties = new Dictionary<string, string>();
-				Dictionary<string, string[]> sets = new Dictionary<string, string[]>();
-				List<string> keywords = new List<string>();
-				List<string> terminals = new List<string>();
-				Dictionary<string, string> specialChars = new Dictionary<string, string>();
-
-				ReadFile(properties, sets, keywords, terminals, specialChars);
-
-				GenerateFiles(properties, sets, keywords, terminals, specialChars);
-			} catch (Exception e) {
-				Debug.Print(e.ToString());
-			}
-		}
-		
-		static void GenerateFiles(Dictionary<string, string> properties, Dictionary<string, string[]> sets,
-		                          List<string> keywords, List<string> terminals, Dictionary<string, string> specialChars)
-		{
-			GenerateKeywords(properties, keywords);
-			GenerateTokens(properties, sets, keywords, terminals, specialChars);
-			GenerateTests(keywords, specialChars);
-			GenerateKeywordSection(keywords, terminals, specialChars);
-		}
-		
-		static void GenerateKeywordSection(List<string> keywords, List<string> terminals, Dictionary<string, string> specialChars)
-		{
-			string sourceDir = Path.Combine(parserBaseDir, "vb.atg");
-			StringBuilder builder = new StringBuilder();
-			
-			builder.AppendLine("/* START AUTOGENERATED TOKENS SECTION */");
-			builder.AppendLine("TOKENS");
-			builder.AppendLine("\t/* ----- terminal classes ----- */");
-			builder.AppendLine("\t/* EOF is 0 */");
-			
-			foreach (string terminal in terminals) {
-				if (terminal == "EOF")
-					continue;
-				if (terminal == "Identifier") {
-					builder.AppendLine("\tident");
-					continue;
-				}
-				builder.AppendLine("\t" + terminal);
-			}
-			
-			builder.AppendLine();
-			builder.AppendLine("\t/* ----- special character ----- */");
-			foreach (string specialChar in specialChars.Values) {
-				builder.AppendLine("\t" + specialChar);
-			}
-			
-			builder.AppendLine();
-			builder.AppendLine("\t/* ----- keywords ----- */");
-			foreach (string keyword in keywords) {
-				builder.AppendLine("\t\"" + keyword + "\"");
-			}
-			
-			builder.AppendLine("/* END AUTOGENERATED TOKENS SECTION */");
-			
-			string[] generatedLines = builder.ToString().Split(new string[] { Environment.NewLine }, StringSplitOptions.None);
-			string[] lines = File.ReadAllLines(sourceDir);
-			
-			var newContent = lines
-				.TakeWhile(l => l != "/* START AUTOGENERATED TOKENS SECTION */")
-				.Concat(generatedLines)
-				.Concat(lines.SkipWhile(l => l != "/* END AUTOGENERATED TOKENS SECTION */").Skip(2))
-				.ToArray();
-
-			File.WriteAllLines(sourceDir, newContent);
-		}
-
-		static void GenerateTests(List<string> keywords, Dictionary<string, string> specialChars)
-		{
-			string sourceDir = Path.Combine(testBaseDir, "LexerTests.cs");
-			using (StreamWriter writer = new StreamWriter(new FileStream(sourceDir, FileMode.Create))) {
-				writer.WriteLine("// this file was autogenerated by a tool.");
-				writer.WriteLine("using System;");
-				writer.WriteLine("using System.IO;");
-				writer.WriteLine("using NUnit.Framework;");
-				writer.WriteLine("using ICSharpCode.NRefactory.VB;");
-				writer.WriteLine("using ICSharpCode.NRefactory.VB.Parser;");
-				writer.WriteLine("using ICSharpCode.NRefactory.VB.PrettyPrinter;");
-				writer.WriteLine();
-				writer.WriteLine("namespace ICSharpCode.NRefactory.VB.Tests.Lexer");
-				writer.WriteLine("{");
-				writer.WriteLine("\t[TestFixture]");
-				writer.WriteLine("\tpublic sealed class LexerTests");
-				writer.WriteLine("\t{");
-				writer.WriteLine("\t\tVBLexer GenerateLexer(StringReader sr)");
-				writer.WriteLine("\t\t{");
-				writer.WriteLine("\t\t\treturn ParserFactory.CreateLexer(sr);");
-				writer.WriteLine("\t\t}");
-				for (int i = 0; i < specialChars.Values.Count; i++) {
-					writer.WriteLine();
-					writer.WriteLine("\t\t[Test]");
-					writer.WriteLine("\t\tpublic void Test{0}()", specialChars.Keys.ElementAt(i));
-					writer.WriteLine("\t\t{");
-					writer.WriteLine("\t\t\tVBLexer lexer = GenerateLexer(new StringReader({0}));", specialChars.Values.ElementAt(i));
-					writer.WriteLine("\t\t\tAssert.AreEqual(Tokens.{0}, lexer.NextToken().Kind);", specialChars.Keys.ElementAt(i));
-					writer.WriteLine("\t\t}");
-				}
-				foreach (string keyword in keywords) {
-					if (keyword == "Rem")
-						continue;
-					writer.WriteLine();
-					writer.WriteLine("\t\t[Test]");
-					writer.WriteLine("\t\tpublic void Test{0}()", UpperCaseFirst(keyword));
-					writer.WriteLine("\t\t{");
-					writer.WriteLine("\t\t\tVBLexer lexer = GenerateLexer(new StringReader(\"{0}\"));", keyword);
-					writer.WriteLine("\t\t\tAssert.AreEqual(Tokens.{0}, lexer.NextToken().Kind);", UpperCaseFirst(keyword));
-					writer.WriteLine("\t\t}");
-				}
-				writer.WriteLine("\t}");
-				writer.WriteLine("}");
-			}
-		}
-
-		static void GenerateTokens(Dictionary<string, string> properties, Dictionary<string, string[]> sets, List<string> keywords, List<string> terminals, Dictionary<string, string> specialChars)
-		{
-			string sourceDir = Path.Combine(baseDir, "Tokens.cs");
-			using (StreamWriter writer = new StreamWriter(new FileStream(sourceDir, FileMode.Create))) {
-				writer.WriteLine("// this file was autogenerated by a tool.");
-				writer.WriteLine("using System;");
-				writer.WriteLine("using System.Collections;");
-				writer.WriteLine();
-				writer.WriteLine("namespace {0}", properties["Namespace"]);
-				writer.WriteLine("{");
-				writer.WriteLine("\tpublic static class Tokens");
-				writer.WriteLine("\t{");
-				writer.WriteLine("\t\t// ----- terminal classes -----");
-				int tokenValue = 0;
-				foreach (string terminal in terminals)
-					writer.WriteToken(terminal, ref tokenValue);
-				writer.WriteLine();
-				writer.WriteLine("\t\t// ----- special character -----");
-				foreach (string specialChar in specialChars.Keys)
-					writer.WriteToken(specialChar, ref tokenValue);
-				writer.WriteLine();
-				writer.WriteLine("\t\t// ----- keywords -----");
-				foreach (string keyword in keywords)
-					writer.WriteToken(keyword, ref tokenValue);
-				writer.WriteLine();
-				writer.WriteLine("\t\tpublic const int MaxToken = {0};", tokenValue);
-				if (sets.Any()) {
-					writer.WriteLine("\t\tstatic BitArray NewSet(params int[] values)");
-					writer.WriteLine("\t\t{");
-					writer.WriteLine("\t\t\tBitArray bitArray = new BitArray(MaxToken);");
-					writer.WriteLine("\t\t\tforeach (int val in values) {");
-					writer.WriteLine("\t\t\tbitArray[val] = true;");
-					writer.WriteLine("\t\t\t}");
-					writer.WriteLine("\t\t\treturn bitArray;");
-					writer.WriteLine("\t\t}");
-					foreach (var pair in sets) {
-						StringBuilder builder = new StringBuilder();
-						PrintList(pair.Value, builder, sets, specialChars);
-						writer.WriteLine("\t\tpublic static BitArray {0} = NewSet({1});", pair.Key, builder.ToString());
-					}
-					writer.WriteLine();
-				}
-
-				// write token number --> string function.
-				writer.WriteLine("\t\tstatic string[] tokenList = new string[] {");
-
-				writer.WriteLine("\t\t\t// ----- terminal classes -----");
-				foreach (string terminal in terminals)
-					writer.WriteLine("\t\t\t\"<{0}>\",", terminal);
-
-				writer.WriteLine("\t\t\t// ----- special character -----");
-				foreach (string specialChar in specialChars.Values)
-					writer.WriteLine("\t\t\t{0},", specialChar);
-
-				writer.WriteLine("\t\t\t// ----- keywords -----");
-				foreach (string keyword in keywords)
-					writer.WriteLine("\t\t\t\"{0}\",", keyword);
-
-				writer.WriteLine("\t\t};");
-
-				writer.WriteLine("\t\tpublic static string GetTokenString(int token)");
-				writer.WriteLine("\t\t{");
-				writer.WriteLine("\t\t\tif (token >= 0 && token < tokenList.Length) {");
-				writer.WriteLine("\t\t\t\treturn tokenList[token];");
-				writer.WriteLine("\t\t\t}");
-				writer.WriteLine("\t\t\tthrow new System.NotSupportedException(\"Unknown token:\" + token);");
-				writer.WriteLine("\t\t}");
-
-				writer.WriteLine("\t}");
-				writer.WriteLine("}");
-			}
-		}
-
-		static void PrintList(string[] value, StringBuilder builder, Dictionary<string, string[]> sets, Dictionary<string, string> specialChars)
-		{
-			for (int i = 0; i < value.Length; i++) {
-				string item = value[i];
-				if (Regex.IsMatch(item, "\\\"(\\w+)\\\"")) // keywords
-					builder.Append(UpperCaseFirst(item.Trim('"', ' ', '\t')));
-				else if (Regex.IsMatch(item, "\\\"(\\W+)\\\"")) // special chars
-					builder.Append(specialChars.Keys.ElementAt(specialChars.Values.FindIndex(it => item == it)));
-				else if (Regex.IsMatch(item, "@(\\w+)")) // other list
-					PrintList(sets[item.Substring(1)], builder, sets, specialChars);
-				else
-					builder.Append(item);
-				if (i + 1 < value.Length)
-					builder.Append(", ");
-			}
-		}
-		
-		static void GenerateKeywords(Dictionary<string, string> properties, List<string> keywords)
-		{
-			string sourceDir = Path.Combine(baseDir, "Keywords.cs");
-			using (StreamWriter writer = new StreamWriter(new FileStream(sourceDir, FileMode.Create))) {
-				writer.WriteLine("// this file was autogenerated by a tool.");
-				writer.WriteLine("using System;");
-				writer.WriteLine();
-				writer.WriteLine("namespace {0}", properties["Namespace"]);
-				writer.WriteLine("{");
-				writer.WriteLine("\tpublic static class Keywords");
-				writer.WriteLine("\t{");
-				writer.WriteLine("\t\tstatic readonly string[] keywordList = {");
-				for (int i = 0; i < keywords.Count; i++) {
-					writer.Write("\t\t\t\"{0}\"", properties["UpperCaseKeywords"] == "True" ? keywords[i].ToUpperInvariant() : keywords[i]);
-					if (i + 1 < keywords.Count)
-						writer.Write(",");
-					writer.WriteLine();
-				}
-				writer.WriteLine("\t\t};");
-				writer.WriteLine("\t\t");
-				writer.WriteLine("\t\tstatic LookupTable keywords = new LookupTable({0});", properties["UpperCaseKeywords"] == "True" ? "false" : "true");
-				writer.WriteLine("\t\t");
-				writer.WriteLine("\t\tstatic Keywords()");
-				writer.WriteLine("\t\t{");
-				writer.WriteLine("\t\t\tfor (int i = 0; i < keywordList.Length; ++i) {");
-				writer.WriteLine("\t\t\t\tkeywords[keywordList[i]] = i + Tokens.{0};", UpperCaseFirst(keywords[0]));
-				writer.WriteLine("\t\t\t}");
-				writer.WriteLine("\t\t}");
-				writer.WriteLine("\t\t");
-				writer.WriteLine("\t\tpublic static int GetToken(string keyword)");
-				writer.WriteLine("\t\t{");
-				writer.WriteLine("\t\t\treturn keywords[keyword];");
-				writer.WriteLine("\t\t}");
-				writer.WriteLine("\t\t");
-				writer.WriteLine("\t\tpublic static bool IsNonIdentifierKeyword(string word)");
-				writer.WriteLine("\t\t{");
-				writer.WriteLine("\t\t\tint token = GetToken(word);");
-				writer.WriteLine("\t\t\tif (token < 0)");
-				writer.WriteLine("\t\t\t\treturn false;");
-				writer.WriteLine("\t\t\treturn !Tokens.IdentifierTokens[token];");
-				writer.WriteLine("\t\t}");
-
-				writer.WriteLine("\t}");
-				writer.WriteLine("}");
-
-				writer.Close();
-			}
-		}
-
-		#region input
-		static void ReadFile(Dictionary<string, string> properties, Dictionary<string, string[]> sets,
-		                     List<string> keywords, List<string> terminals, Dictionary<string, string> specialChars)
-		{
-			string sourceDir = Path.Combine(baseDir, "KeywordList.txt");
-			
-			using (StreamReader reader = new StreamReader(new FileStream(sourceDir, FileMode.Open))) {
-				string line = reader.ReadLine();
-				while (line != null) {
-					ReadProperty(properties, line);
-					ReadKeyword(keywords, line);
-					ReadSet(sets, line);
-					ReadTerminalSymbol(terminals, line);
-					ReadSpecialChar(specialChars, line);
-					line = reader.ReadLine();
-				}
-				reader.Close();
-			}
-		}
-
-		static void ReadProperty(Dictionary<string, string> properties, string line)
-		{
-			// properties form: $PROPERTY = "VALUE"
-			Match match = Regex.Match(line, @"^\s*\$(\w+)\s*=\s*(\S+)\s*$");
-			
-			if (match.Success) {
-				properties.Add(match.Groups[1].Value, match.Groups[2].Value);
-			}
-		}
-
-		static void ReadKeyword(List<string> keywords, string line)
-		{
-			// special keywords form: "VALUE"
-			Match match = Regex.Match(line, "^\\s*\\\"(\\S+)\\s*\\\"\\s*$");
-			
-			if (match.Success) {
-				keywords.Add(match.Groups[1].Value);
-			}
-		}
-
-		static void ReadSet(Dictionary<string, string[]> sets, string line)
-		{
-			// sets form: NAME(comma separated list)
-			Match match = Regex.Match(line, @"^\s*(\w+)\s*\((.*)\)\s*$");
-			
-			if (match.Success) {
-				sets.Add(
-					match.Groups[1].Value,
-					match.Groups[2].Value.Split(new[] {", "}, StringSplitOptions.None)
-				);
-			}
-		}
-
-		static void ReadTerminalSymbol(List<string> terminals, string line)
-		{
-			// special terminal classes form: name
-			Match match = Regex.Match(line, @"^\s*(\w+)\s*$");
-			
-			if (match.Success) {
-				terminals.Add(match.Groups[1].Value);
-			}
-		}
-
-		static void ReadSpecialChar(Dictionary<string, string> specialChars, string line)
-		{
-			// special characters form: name = "VALUE"
-			Match match = Regex.Match(line, @"^\s*(\w+)\s*=\s*(\S+)\s*$");
-			
-			if (match.Success) {
-				specialChars.Add(match.Groups[1].Value, match.Groups[2].Value);
-			}
-		}
-		#endregion
-		
-		#region helpers
-		static string UpperCaseFirst(string keyword)
-		{
-			return char.ToUpperInvariant(keyword[0]) + keyword.Substring(1);
-		}
-		
-		static void WriteToken(this StreamWriter writer, string tokenName, ref int tokenValue)
-		{
-			string formattedName = UpperCaseFirst(tokenName).PadRight(20);
-			if (tokenName == "GetType" || tokenName.ToLowerInvariant() == "equals")
-				writer.WriteLine("\t\tnew public const int {0} = {1};", formattedName, tokenValue);
-			else
-				writer.WriteLine("\t\tpublic const int {0} = {1};", formattedName, tokenValue);
-			tokenValue++;
-		}
-		
-		static int FindIndex<T>(this IEnumerable<T> items, Func<T, bool> f)
-		{
-			int index = -1;
-			foreach (T item in items) {
-				index++;
-				if (f(item))
-					return index;
-			}
-			
-			return -1;
-		}
-		#endregion
-	}
-}
diff --git a/NRefactory/VBAstGenerator/Main.cs b/NRefactory/VBAstGenerator/Main.cs
deleted file mode 100644
index 718521129..000000000
--- a/NRefactory/VBAstGenerator/Main.cs
+++ /dev/null
@@ -1,591 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using System.Collections.Generic;
-using System.CodeDom;
-using System.Diagnostics;
-using System.Reflection;
-using System.IO;
-using VBAstGenerator.Ast;
-using ICSharpCode.EasyCodeDom;
-
-namespace VBAstGenerator
-{
-	class MainClass
-	{
-		public const string VisitPrefix = "Visit";
-		
-		static readonly string[] lineEndings = { "\r\n", "\r", "\n" };
-		
-		public static void Main(string[] args)
-		{
-			string directory = "../../../ICSharpCode.NRefactory.VB/Ast/";
-			string visitorsDir = "../../../ICSharpCode.NRefactory.VB/Visitors/";
-			
-			Debug.WriteLine("AST Generator running...");
-			if (!File.Exists(directory + "INode.cs")) {
-				Debug.WriteLine("did not find output directory");
-				return;
-			}
-			if (!File.Exists(visitorsDir + "AbstractAstTransformer.cs")) {
-				Debug.WriteLine("did not find visitor output directory");
-				return;
-			}
-			
-			List<Type> nodeTypes = new List<Type>();
-			foreach (Type type in typeof(MainClass).Assembly.GetTypes()) {
-				if (type.IsClass && typeof(INode).IsAssignableFrom(type)) {
-					nodeTypes.Add(type);
-				}
-			}
-			nodeTypes.Sort(delegate(Type a, Type b) { return a.Name.CompareTo(b.Name); });
-			
-			CodeCompileUnit ccu = new CodeCompileUnit();
-			CodeNamespace cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Ast");
-			cns.AddImport("System");
-			cns.AddImport("System.Collections.Generic");
-			foreach (Type type in nodeTypes) {
-				if (type.GetCustomAttributes(typeof(CustomImplementationAttribute), false).Length == 0) {
-					CodeTypeDeclaration ctd = cns.AddType(type.Name);
-					if (type.IsAbstract) {
-						ctd.TypeAttributes |= TypeAttributes.Abstract;
-					}
-					ctd.BaseTypes.Add(new CodeTypeReference(type.BaseType.Name));
-					
-					ProcessType(type, ctd);
-					
-					foreach (object o in type.GetCustomAttributes(false)) {
-						if (o is TypeImplementationModifierAttribute) {
-							(o as TypeImplementationModifierAttribute).ModifyImplementation(cns, ctd, type);
-						}
-					}
-					
-					if (!type.IsAbstract) {
-						CodeMemberMethod method = new CodeMemberMethod();
-						method.Name = "AcceptVisitor";
-						method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-						method.Parameters.Add(new CodeParameterDeclarationExpression("IAstVisitor", "visitor"));
-						method.Parameters.Add(new CodeParameterDeclarationExpression(typeof(object), "data"));
-						method.ReturnType = new CodeTypeReference(typeof(object));
-						CodeExpression ex = new CodeVariableReferenceExpression("visitor");
-						ex = new CodeMethodInvokeExpression(ex, VisitPrefix + ctd.Name,
-						                                    new CodeThisReferenceExpression(),
-						                                    new CodeVariableReferenceExpression("data"));
-						method.Statements.Add(new CodeMethodReturnStatement(ex));
-						ctd.Members.Add(method);
-						
-						method = new CodeMemberMethod();
-						method.Name = "ToString";
-						method.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-						method.ReturnType = new CodeTypeReference(typeof(string));
-						method.Statements.Add(new CodeMethodReturnStatement(CreateToString(type)));
-						ctd.Members.Add(method);
-					}
-				}
-			}
-			
-			System.CodeDom.Compiler.CodeGeneratorOptions settings = new System.CodeDom.Compiler.CodeGeneratorOptions();
-			settings.IndentString = "\t";
-			settings.VerbatimOrder = true;
-			
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(directory + "Generated.cs", NormalizeNewLines(writer));
-			}
-			
-			ccu = new CodeCompileUnit();
-			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB");
-			cns.AddImport("System");
-			cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
-			cns.Types.Add(CreateAstVisitorInterface(nodeTypes));
-			
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "../IAstVisitor.cs", NormalizeNewLines(writer));
-			}
-			
-			ccu = new CodeCompileUnit();
-			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
-			cns.AddImport("System");
-			cns.AddImport("System.Collections.Generic");
-			cns.AddImport("System.Diagnostics");
-			cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
-			cns.Types.Add(CreateAstVisitorClass(nodeTypes, false));
-			
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "AbstractAstVisitor.cs", NormalizeNewLines(writer));
-			}
-			
-			ccu = new CodeCompileUnit();
-			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
-			cns.AddImport("System");
-			cns.AddImport("System.Collections.Generic");
-			cns.AddImport("System.Diagnostics");
-			cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
-			cns.Types.Add(CreateAstVisitorClass(nodeTypes, true));
-			
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "AbstractAstTransformer.cs", NormalizeNewLines(writer));
-			}
-			
-			ccu = new CodeCompileUnit();
-			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
-			cns.AddImport("System");
-			cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
-			cns.Types.Add(CreateNodeTrackingAstVisitorClass(nodeTypes));
-			
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				// CodeDom cannot output "sealed", so we need to use this hack:
-				File.WriteAllText(visitorsDir + "NodeTrackingAstVisitor.cs",
-				                  NormalizeNewLines(writer).Replace("public override object", "public sealed override object"));
-			}
-			
-			//NotImplementedAstVisitor
-			ccu = new CodeCompileUnit();
-			cns = ccu.AddNamespace("ICSharpCode.NRefactory.VB.Visitors");
-			cns.AddImport("System");
-			cns.AddImport("ICSharpCode.NRefactory.VB.Ast");
-			cns.Types.Add(CreateNotImplementedAstVisitorClass(nodeTypes));
-			
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromCompileUnit(ccu, writer, settings);
-				File.WriteAllText(visitorsDir + "NotImplementedAstVisitor.cs", NormalizeNewLines(writer));
-			}
-			Debug.WriteLine("DOM Generator done!");
-			
-			Debug.WriteLine("start keyword list generation...");
-			
-			KeywordGenerator.Generate();
-			
-			Debug.WriteLine("keyword list generation done!");
-		}
-		
-		static string NormalizeNewLines(StringWriter writer)
-		{
-			return string.Join(Environment.NewLine, writer.ToString().Split(lineEndings, StringSplitOptions.None));
-		}
-		
-		static CodeTypeDeclaration CreateAstVisitorInterface(List<Type> nodeTypes)
-		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration("IAstVisitor");
-			td.IsInterface = true;
-			
-			foreach (Type t in nodeTypes) {
-				if (!t.IsAbstract) {
-					EasyMethod m = td.AddMethod(typeof(object), VisitPrefix + t.Name);
-					m.AddParameter(ConvertType(t), GetFieldName(t.Name));
-					m.AddParameter(typeof(object), "data");
-				}
-			}
-			return td;
-		}
-		
-		static CodeTypeDeclaration CreateAstVisitorClass(List<Type> nodeTypes, bool transformer)
-		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration(transformer ? "AbstractAstTransformer" : "AbstractAstVisitor");
-			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Abstract;
-			td.BaseTypes.Add(new CodeTypeReference("IAstVisitor"));
-			
-			if (transformer) {
-				string comment =
-					"The AbstractAstTransformer will iterate through the whole Ast,\n " +
-					"just like the AbstractAstVisitor. However, the AbstractAstTransformer allows\n " +
-					"you to modify the Ast at the same time: It does not use 'foreach' internally,\n " +
-					"so you can add members to collections of parents of the current node (but\n " +
-					"you cannot insert or delete items as that will make the index used invalid).\n " +
-					"You can use the methods ReplaceCurrentNode and RemoveCurrentNode to replace\n " +
-					"or remove the current node, totally independent from the type of the parent node.";
-				Easy.AddSummary(td, comment);
-				
-				CodeMemberField field = td.AddField(Easy.TypeRef("Stack", "INode"), "nodeStack");
-				field.InitExpression = Easy.New(field.Type);
-				
-				/*
-				CodeExpression nodeStack = Easy.Var("nodeStack");
-				CodeMemberProperty p = new CodeMemberProperty();
-				p.Name = "CurrentNode";
-				p.Type = new CodeTypeReference("INode");
-				p.Attributes = MemberAttributes.Public | MemberAttributes.Final;
-				p.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression("currentNode")));
-				p.SetStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("currentNode"),
-				                                            new CodePropertySetValueReferenceExpression()));
-				td.Members.Add(p);
-				 */
-				
-				EasyMethod m = td.AddMethod("ReplaceCurrentNode");
-				m.AddParameter(Easy.TypeRef("INode"), "newNode");
-				m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Pop"));
-				m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Push", Easy.Var("newNode")));
-				
-				m = td.AddMethod("RemoveCurrentNode");
-				m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Pop"));
-				m.Statements.Add(Easy.Var("nodeStack").InvokeMethod("Push", Easy.Null));
-			}
-			
-			foreach (Type type in nodeTypes) {
-				if (!type.IsAbstract) {
-					EasyMethod m = td.AddMethod(typeof(object), VisitPrefix + type.Name);
-					m.Attributes = MemberAttributes.Public;
-					m.AddParameter(ConvertType(type), GetFieldName(type.Name));
-					m.AddParameter(typeof(object), "data");
-					
-					List<CodeStatement> assertions = new List<CodeStatement>();
-					string varVariableName = GetFieldName(type.Name);
-					CodeExpression var = Easy.Var(varVariableName);
-					assertions.Add(AssertIsNotNull(var));
-					
-					AddFieldVisitCode(m, type, var, assertions, transformer);
-					
-					if (type.GetCustomAttributes(typeof(HasChildrenAttribute), true).Length > 0) {
-						if (transformer) {
-							m.Statements.Add(new CodeSnippetStatement(CreateTransformerLoop(varVariableName + ".Children", "INode")));
-							m.Body.Return(Easy.Null);
-						} else {
-							m.Body.Return(var.InvokeMethod("AcceptChildren", Easy.This, Easy.Var("data")));
-						}
-					} else {
-						CodeExpressionStatement lastStatement = null;
-						if (m.Statements.Count > 0) {
-							lastStatement = m.Statements[m.Statements.Count - 1] as CodeExpressionStatement;
-						}
-						if (lastStatement != null) {
-							m.Statements.RemoveAt(m.Statements.Count - 1);
-							m.Body.Return(lastStatement.Expression);
-						} else {
-							m.Body.Return(Easy.Null);
-						}
-					}
-					
-					for (int i = 0; i < assertions.Count; i++) {
-						m.Statements.Insert(i, assertions[i]);
-					}
-				}
-			}
-			return td;
-		}
-		
-		static void AddFieldVisitCode(EasyMethod m, Type type, CodeExpression var, List<CodeStatement> assertions, bool transformer)
-		{
-			if (type != null) {
-				if (type.BaseType != typeof(StatementWithEmbeddedStatement)) {
-					AddFieldVisitCode(m, type.BaseType, var, assertions, transformer);
-				}
-				foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)) {
-					AddVisitCode(m, field, var, assertions, transformer);
-				}
-				if (type.BaseType == typeof(StatementWithEmbeddedStatement)) {
-					AddFieldVisitCode(m, type.BaseType, var, assertions, transformer);
-				}
-			}
-		}
-		
-		static CodeStatement AssertIsNotNull(CodeExpression expr)
-		{
-			return new CodeExpressionStatement(
-				Easy.Type("Debug").InvokeMethod("Assert",
-				                                Easy.Binary(expr,
-				                                            CodeBinaryOperatorType.IdentityInequality,
-				                                            Easy.Null))
-			);
-		}
-		
-		static string GetCode(CodeExpression ex)
-		{
-			using (StringWriter writer = new StringWriter()) {
-				new Microsoft.CSharp.CSharpCodeProvider().GenerateCodeFromExpression(ex, writer, null);
-				return writer.ToString();
-			}
-		}
-		
-		static string CreateTransformerLoop(string collection, string typeName)
-		{
-			return
-				"\t\t\tfor (int i = 0; i < " + collection + ".Count; i++) {\n" +
-				"\t\t\t\t" + typeName + " o = " + collection + "[i];\n" +
-				"\t\t\t\tDebug.Assert(o != null);\n" +
-				"\t\t\t\tnodeStack.Push(o);\n" +
-				"\t\t\t\to.AcceptVisitor(this, data);\n" +
-				(typeName == "INode"
-				 ? "\t\t\t\to = nodeStack.Pop();\n"
-				 : "\t\t\t\to = (" + typeName + ")nodeStack.Pop();\n") +
-				"\t\t\t\tif (o == null)\n" +
-				"\t\t\t\t\t" + collection + ".RemoveAt(i--);\n" +
-				"\t\t\t\telse\n" +
-				"\t\t\t\t\t" + collection + "[i] = o;\n" +
-				"\t\t\t}";
-		}
-		
-		static bool AddVisitCode(EasyMethod m, FieldInfo field, CodeExpression var, List<CodeStatement> assertions, bool transformer)
-		{
-			CodeExpression prop = var.Property(GetPropertyName(field.Name));
-			CodeExpression nodeStack = Easy.Var("nodeStack");
-			if (field.FieldType.FullName.StartsWith("System.Collections.Generic.List")) {
-				Type elType = field.FieldType.GetGenericArguments()[0];
-				if (!typeof(INode).IsAssignableFrom(elType))
-					return false;
-				assertions.Add(AssertIsNotNull(prop));
-				string code;
-				if (transformer) {
-					code = CreateTransformerLoop(GetCode(prop), ConvertType(elType).BaseType);
-				} else {
-					code =
-						"\t\t\tforeach (" + ConvertType(elType).BaseType + " o in " + GetCode(prop) + ") {\n" +
-						"\t\t\t\tDebug.Assert(o != null);\n" +
-						"\t\t\t\to.AcceptVisitor(this, data);\n" +
-						"\t\t\t}";
-				}
-				m.Statements.Add(new CodeSnippetStatement(code));
-				return true;
-			}
-			if (!typeof(INode).IsAssignableFrom(field.FieldType))
-				return false;
-			assertions.Add(AssertIsNotNull(prop));
-			if (transformer) {
-				m.Statements.Add(nodeStack.InvokeMethod("Push", prop));
-			}
-			m.Statements.Add(prop.InvokeMethod("AcceptVisitor",
-			                                   Easy.This,
-			                                   Easy.Var("data")));
-			if (transformer) {
-				m.Body.Assign(prop, nodeStack.InvokeMethod("Pop").CastTo(ConvertType(field.FieldType)));
-			}
-			return true;
-		}
-		
-		static CodeExpression CreateToString(Type type)
-		{
-			CodeMethodInvokeExpression ie = new CodeMethodInvokeExpression(new CodeTypeReferenceExpression(typeof(string)),
-			                                                               "Format");
-			CodePrimitiveExpression prim = new CodePrimitiveExpression();
-			ie.Parameters.Add(prim);
-			string text = "[" + type.Name;
-			int index = 0;
-			do {
-				foreach (FieldInfo field in type.GetFields(BindingFlags.Instance | BindingFlags.NonPublic)) {
-					text += " " + GetPropertyName(field.Name) + "={" + index.ToString() + "}";
-					index++;
-					if (typeof(System.Collections.ICollection).IsAssignableFrom(field.FieldType)) {
-						ie.Parameters.Add(new CodeSnippetExpression("GetCollectionString(" + GetPropertyName(field.Name) + ")"));
-					} else {
-						ie.Parameters.Add(new CodeVariableReferenceExpression(GetPropertyName(field.Name)));
-					}
-				}
-				type = type.BaseType;
-			} while (type != null);
-			prim.Value = text + "]";
-			if (ie.Parameters.Count == 1)
-				return prim;
-			else
-				return ie;
-			//	return String.Format("[AnonymousMethodExpression: Parameters={0} Body={1}]",
-			//	                     GetCollectionString(Parameters),
-			//	                     Body);
-		}
-		
-		static void ProcessType(Type type, CodeTypeDeclaration ctd)
-		{
-			foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic)) {
-				ctd.AddField(ConvertType(field.FieldType), field.Name).Attributes = 0;
-			}
-			foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic)) {
-				EasyProperty p = ctd.AddProperty(ConvertType(field.FieldType), GetPropertyName(field.Name));
-				p.Getter.Return(Easy.Var(field.Name));
-				CodeExpression ex;
-				if (field.FieldType.IsValueType)
-					ex = new CodePropertySetValueReferenceExpression();
-				else
-					ex = GetDefaultValue("value", field);
-				p.Setter.Assign(Easy.Var(field.Name), ex);
-				if (typeof(INode).IsAssignableFrom(field.FieldType)) {
-					if (typeof(INullable).IsAssignableFrom(field.FieldType)) {
-						p.SetStatements.Add(new CodeSnippetStatement("\t\t\t\tif (!" +field.Name+".IsNull) "+field.Name+".Parent = this;"));
-					} else {
-						p.SetStatements.Add(new CodeSnippetStatement("\t\t\t\t"+field.Name+".Parent = this;"));
-					}
-				}
-			}
-			foreach (ConstructorInfo ctor in type.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)) {
-				CodeConstructor c = new CodeConstructor();
-				if (type.IsAbstract)
-					c.Attributes = MemberAttributes.Family;
-				else
-					c.Attributes = MemberAttributes.Public;
-				ctd.Members.Add(c);
-				ConstructorInfo baseCtor = GetBaseCtor(type);
-				foreach(ParameterInfo param in ctor.GetParameters()) {
-					c.Parameters.Add(new CodeParameterDeclarationExpression(ConvertType(param.ParameterType),
-					                                                        param.Name));
-					if (baseCtor != null && Array.Exists(baseCtor.GetParameters(), delegate(ParameterInfo p) { return param.Name == p.Name; }))
-						continue;
-					c.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(GetPropertyName(param.Name)),
-					                                         new CodeVariableReferenceExpression(param.Name)));
-				}
-				if (baseCtor != null) {
-					foreach(ParameterInfo param in baseCtor.GetParameters()) {
-						c.BaseConstructorArgs.Add(new CodeVariableReferenceExpression(param.Name));
-					}
-				}
-				// initialize fields that were not initialized by parameter
-				foreach (FieldInfo field in type.GetFields(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.NonPublic)) {
-					if (field.FieldType.IsValueType && field.FieldType != typeof(Location))
-						continue;
-					if (Array.Exists(ctor.GetParameters(), delegate(ParameterInfo p) { return field.Name == p.Name; }))
-						continue;
-					c.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(field.Name),
-					                                         GetDefaultValue(null, field)));
-				}
-			}
-		}
-		
-		internal static ConstructorInfo GetBaseCtor(Type type)
-		{
-			ConstructorInfo[] list = type.BaseType.GetConstructors();
-			if (list.Length == 0)
-				return null;
-			else
-				return list[0];
-		}
-		
-		internal static CodeExpression GetDefaultValue(string inputVariable, FieldInfo field)
-		{
-			string code;
-			// get default value:
-			if (field.FieldType == typeof(string)) {
-				code = "\"\"";
-				if (field.GetCustomAttributes(typeof(QuestionMarkDefaultAttribute), false).Length > 0) {
-					if (inputVariable == null)
-						return new CodePrimitiveExpression("?");
-					else
-						return new CodeSnippetExpression("string.IsNullOrEmpty(" + inputVariable + ") ? \"?\" : " + inputVariable);
-				}
-			} else if (field.FieldType.FullName.StartsWith("System.Collections.Generic.List")) {
-				code = "new List<" + field.FieldType.GetGenericArguments()[0].Name + ">()";
-			} else if (field.FieldType == typeof(Location)) {
-				code = "Location.Empty";
-			} else {
-				code = field.FieldType.Name + ".Null";
-			}
-			if (inputVariable != null) {
-				code = inputVariable + " ?? " + code;
-			}
-			return new CodeSnippetExpression(code);
-		}
-		
-		internal static string GetFieldName(string typeName)
-		{
-			return char.ToLower(typeName[0]) + typeName.Substring(1);
-		}
-		
-		internal static string GetPropertyName(string fieldName)
-		{
-			return char.ToUpper(fieldName[0]) + fieldName.Substring(1);
-		}
-		
-		internal static CodeTypeReference ConvertType(Type type)
-		{
-			if (type.IsGenericType && !type.IsGenericTypeDefinition) {
-				CodeTypeReference tr = ConvertType(type.GetGenericTypeDefinition());
-				foreach (Type subType in type.GetGenericArguments()) {
-					tr.TypeArguments.Add(ConvertType(subType));
-				}
-				return tr;
-			} else if (type.FullName.StartsWith("VBAst") || type.FullName.StartsWith("System.Collections")) {
-				if (type.Name == "Attribute")
-					return new CodeTypeReference("ICSharpCode.NRefactory.VB.Ast.Attribute");
-				return new CodeTypeReference(type.Name);
-			} else {
-				return new CodeTypeReference(type);
-			}
-		}
-		
-		static CodeTypeDeclaration CreateNodeTrackingAstVisitorClass(List<Type> nodeTypes)
-		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration("NodeTrackingAstVisitor");
-			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class | TypeAttributes.Abstract;
-			td.BaseTypes.Add(new CodeTypeReference("AbstractAstVisitor"));
-			
-			string comment = "<summary>\n " +
-				"The NodeTrackingAstVisitor will iterate through the whole Ast,\n " +
-				"just like the AbstractAstVisitor, and calls the virtual methods\n " +
-				"BeginVisit and EndVisit for each node being visited.\n " +
-				"</summary>";
-			td.Comments.Add(new CodeCommentStatement(comment, true));
-			comment = "<remarks>\n " +
-				"base.Visit(node, data) calls this.TrackedVisit(node, data), so if\n " +
-				"you want to visit child nodes using the default visiting behaviour,\n " +
-				"use base.TrackedVisit(parentNode, data).\n " +
-				"</remarks>";
-			td.Comments.Add(new CodeCommentStatement(comment, true));
-			
-			EasyMethod m = td.AddMethod("BeginVisit");
-			m.Attributes = MemberAttributes.Family;
-			m.AddParameter(Easy.TypeRef("INode"), "node");
-			
-			m = td.AddMethod("EndVisit");
-			m.Attributes = MemberAttributes.Family;
-			m.AddParameter(Easy.TypeRef("INode"), "node");
-			
-			foreach (Type type in nodeTypes) {
-				if (!type.IsAbstract) {
-					
-					m = td.AddMethod(typeof(object), VisitPrefix + type.Name);
-					m.Attributes = MemberAttributes.Public | MemberAttributes.Override;
-					m.AddParameter(ConvertType(type), GetFieldName(type.Name));
-					m.AddParameter(new CodeTypeReference(typeof(object)), "data");
-					
-					CodeExpression var = Easy.Var(GetFieldName(type.Name));
-					
-					m.Body.InvokeMethod(Easy.This, "BeginVisit", var);
-					m.Body.DeclareVariable(typeof(object), "result").InitExpression
-						= Easy.This.InvokeMethod("TrackedVisit" + type.Name, var, Easy.Var("data"));
-					m.Body.InvokeMethod(Easy.This, "EndVisit", var);
-					m.Body.Return(Easy.Var("result"));
-				}
-			}
-			
-			foreach (Type type in nodeTypes) {
-				if (!type.IsAbstract) {
-					
-					m = td.AddMethod(typeof(object), "TrackedVisit" + type.Name);
-					m.Attributes = MemberAttributes.Public;
-					m.AddParameter(ConvertType(type), GetFieldName(type.Name));
-					m.AddParameter(new CodeTypeReference(typeof(object)), "data");
-					
-					m.Body.Return(Easy.Base.InvokeMethod(VisitPrefix + type.Name, Easy.Var(GetFieldName(type.Name)), Easy.Var("data")));
-				}
-			}
-			
-			return td;
-		}
-		
-		static CodeTypeDeclaration CreateNotImplementedAstVisitorClass(List<Type> nodeTypes)
-		{
-			CodeTypeDeclaration td = new CodeTypeDeclaration("NotImplementedAstVisitor");
-			td.TypeAttributes = TypeAttributes.Public | TypeAttributes.Class;
-			td.BaseTypes.Add(new CodeTypeReference("IAstVisitor"));
-			
-			string comment = "<summary>\n " +
-				"IAstVisitor implementation that always throws NotImplementedExceptions.\n " +
-				"</summary>";
-			td.Comments.Add(new CodeCommentStatement(comment, true));
-			
-			foreach (Type type in nodeTypes) {
-				if (!type.IsAbstract) {
-					
-					EasyMethod m = td.AddMethod(typeof(object), VisitPrefix + type.Name);
-					m.Attributes = MemberAttributes.Public;
-					m.AddParameter(ConvertType(type), GetFieldName(type.Name));
-					m.AddParameter(new CodeTypeReference(typeof(object)), "data");
-					
-					m.Body.Throw(Easy.New(typeof(NotImplementedException), Easy.Prim(type.Name)));
-				}
-			}
-			
-			return td;
-		}
-	}
-}
diff --git a/NRefactory/VBAstGenerator/VBAstGenerator.csproj b/NRefactory/VBAstGenerator/VBAstGenerator.csproj
deleted file mode 100644
index cbc0bb47e..000000000
--- a/NRefactory/VBAstGenerator/VBAstGenerator.csproj
+++ /dev/null
@@ -1,64 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <RootNamespace>VBAstGenerator</RootNamespace>
-    <AssemblyName>VBAstGenerator</AssemblyName>
-    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
-    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProjectGuid>{B22522AA-B5BF-4A58-AC6D-D4B45805521F}</ProjectGuid>
-    <AllowUnsafeBlocks>False</AllowUnsafeBlocks>
-    <NoStdLib>False</NoStdLib>
-    <RegisterForComInterop>False</RegisterForComInterop>
-    <GenerateSerializationAssemblies>Auto</GenerateSerializationAssemblies>
-    <BaseAddress>4194304</BaseAddress>
-    <PlatformTarget>x86</PlatformTarget>
-    <FileAlignment>4096</FileAlignment>
-    <WarningLevel>4</WarningLevel>
-    <NoWarn>0169</NoWarn>
-    <TreatWarningsAsErrors>false</TreatWarningsAsErrors>
-    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
-    <RunPostBuildEvent>OnBuildSuccess</RunPostBuildEvent>
-    <TargetFrameworkProfile>Client</TargetFrameworkProfile>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Debug' ">
-    <OutputPath>bin\Debug\</OutputPath>
-    <Optimize>False</Optimize>
-    <DefineConstants>DEBUG;TRACE</DefineConstants>
-    <DebugSymbols>true</DebugSymbols>
-    <DebugType>Full</DebugType>
-    <CheckForOverflowUnderflow>True</CheckForOverflowUnderflow>
-  </PropertyGroup>
-  <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
-    <OutputPath>bin\Release\</OutputPath>
-    <Optimize>True</Optimize>
-    <DefineConstants>TRACE</DefineConstants>
-    <DebugSymbols>False</DebugSymbols>
-    <DebugType>None</DebugType>
-    <CheckForOverflowUnderflow>False</CheckForOverflowUnderflow>
-  </PropertyGroup>
-  <ItemGroup>
-    <Reference Include="System" />
-    <Reference Include="System.Core">
-      <RequiredTargetFramework>3.5</RequiredTargetFramework>
-    </Reference>
-    <Reference Include="System.Data" />
-    <Reference Include="System.Xml" />
-  </ItemGroup>
-  <ItemGroup>
-    <Compile Include="EasyCodeDom.cs" />
-    <Compile Include="KeywordGenerator.cs" />
-    <Compile Include="Main.cs" />
-    <Compile Include="AssemblyInfo.cs" />
-    <Compile Include="Ast\Expressions.cs" />
-    <Compile Include="Attributes.cs" />
-    <Compile Include="Ast\Node.cs" />
-    <Compile Include="Ast\Statements.cs" />
-    <Compile Include="Ast\TypeLevel.cs" />
-    <Compile Include="Ast\GlobalLevel.cs" />
-  </ItemGroup>
-  <ItemGroup>
-    <Folder Include="Ast" />
-  </ItemGroup>
-  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
-</Project>
\ No newline at end of file