void InferTypes(ILNode node)
		{
			ILCondition cond = node as ILCondition;
			if (cond != null) {
				InferTypeForExpression(cond.Condition, typeSystem.Boolean, false);
			}
			ILWhileLoop loop = node as ILWhileLoop;
			if (loop != null && loop.Condition != null) {
				InferTypeForExpression(loop.Condition, typeSystem.Boolean, false);
			}
			ILExpression expr = node as ILExpression;
			if (expr != null) {
				ILVariable v = expr.Operand as ILVariable;
				if (v != null && v.IsGenerated && v.Type == null && expr.Code == ILCode.Stloc && !inferredVariables.Contains(v) && HasSingleLoad(v)) {
					// Don't deal with this node or its children yet,
					// wait for the expected type to be inferred first.
					// This happens with the arg_... variables introduced by the ILAst - we skip inferring the whole statement,
					// and first infer the statement that reads from the arg_... variable.
					// The ldloc inference will write the expected type to the variable, and the next InferRemainingStores() pass
					// will then infer this statement with the correct expected type.
					storedToGeneratedVariables.Add(expr);
					return;
				}
				bool anyArgumentIsMissingType = expr.Arguments.Any(a => a.InferredType == null);
				if (expr.InferredType == null || anyArgumentIsMissingType)
					expr.InferredType = InferTypeForExpression(expr, expr.ExpectedType, forceInferChildren: anyArgumentIsMissingType);
			}
			foreach (ILNode child in node.GetChildren()) {
				InferTypes(child);
			}
		}

		/// <summary>
		/// Creates the "ExpressionToInfer" instances (=nodes in dependency graph)
		/// </summary>
		/// <remarks>
		/// We are using a dependency graph to ensure that expressions are analyzed in the correct order.
		/// </remarks>
		void CreateDependencyGraph(ILNode node)
		{
			ILCondition cond = node as ILCondition;
			if (cond != null) {
				cond.Condition.ExpectedType = typeSystem.Boolean;
			}
			ILWhileLoop loop = node as ILWhileLoop;
			if (loop != null && loop.Condition != null) {
				loop.Condition.ExpectedType = typeSystem.Boolean;
			}
			ILTryCatchBlock.CatchBlock catchBlock = node as ILTryCatchBlock.CatchBlock;
			if (catchBlock != null && catchBlock.ExceptionVariable != null && catchBlock.ExceptionType != null && catchBlock.ExceptionVariable.Type == null) {
				catchBlock.ExceptionVariable.Type = catchBlock.ExceptionType;
			}
			ILExpression expr = node as ILExpression;
			if (expr != null) {
				ExpressionToInfer expressionToInfer = new ExpressionToInfer();
				expressionToInfer.Expression = expr;
				allExpressions.Add(expressionToInfer);
				FindNestedAssignments(expr, expressionToInfer);
				
				if (expr.Code == ILCode.Stloc && ((ILVariable)expr.Operand).Type == null)
					assignmentExpressions[(ILVariable)expr.Operand].Add(expressionToInfer);
				return;
			}
			foreach (ILNode child in node.GetChildren()) {
				CreateDependencyGraph(child);
			}
		}

		/// <summary>
		/// For each variable reference, adds <paramref name="direction"/> to the num* dicts.
		/// Direction will be 1 for analysis, and -1 when removing a node from analysis.
		/// </summary>
		void AnalyzeNode(ILNode node, int direction = 1)
		{
			ILExpression expr = node as ILExpression;
			if (expr != null) {
				ILVariable locVar = expr.Operand as ILVariable;
				if (locVar != null) {
					if (expr.Code == ILCode.Stloc) {
						numStloc[locVar] = numStloc.GetOrDefault(locVar) + direction;
					} else if (expr.Code == ILCode.Ldloc) {
						numLdloc[locVar] = numLdloc.GetOrDefault(locVar) + direction;
					} else if (expr.Code == ILCode.Ldloca) {
						numLdloca[locVar] = numLdloca.GetOrDefault(locVar) + direction;
					} else {
						throw new NotSupportedException(expr.Code.ToString());
					}
				}
				foreach (ILExpression child in expr.Arguments)
					AnalyzeNode(child, direction);
			} else {
				var catchBlock = node as ILTryCatchBlock.CatchBlock;
				if (catchBlock != null && catchBlock.ExceptionVariable != null) {
					numStloc[catchBlock.ExceptionVariable] = numStloc.GetOrDefault(catchBlock.ExceptionVariable) + direction;
				}
				
				foreach (ILNode child in node.GetChildren())
					AnalyzeNode(child, direction);
			}
		}

		public bool addCreateNewNode(ILNode node, int pos)
		{
			
			if (newBody.ContainsKey (pos)) {
				return addNewNode (node, maxCodePos+1);	
			} else {
				return addNewNode (node, pos);
			}
		}

		public override bool Match(ILNode other)
		{
			ILExpression expr = other as ILExpression;
			if (expr != null && expr.Code == ILCode.Stloc && (!MustBeGenerated || ((ILVariable)expr.Operand).IsGenerated) && Match(this.Arguments, expr.Arguments)) {
				this.LastMatch = expr;
				return true;
			} else {
				return false;
			}
		}

		public static void AddILRangesTryPreviousFirst(ILNode prev, ILNode next, ILBlockBase block, IEnumerable<ILRange> ilRanges)
		{
			if (prev != null && prev.SafeToAddToEndILRanges)
				prev.EndILRanges.AddRange(ilRanges);
			else if (next != null)
				next.ILRanges.AddRange(ilRanges);
			else if (prev != null)
				block.EndILRanges.AddRange(ilRanges);
			else
				block.ILRanges.AddRange(ilRanges);
		}

		public bool addNewNode(ILNode node, int pos)
		{
			if (newBody.ContainsKey (pos)) {
				return false;
			}


			if (pos > maxCodePos) {
				maxCodePos = pos;
			}
			this.newBody.Add (pos,node);
			return true;
		}

		/// <summary>
		/// Inlines 'expr' into 'next', if possible.
		/// </summary>
		public static bool InlineIfPossible(ILExpression expr, ILNode next, ILBlock method)
		{
			if (expr.Code != ILCode.Stloc)
				throw new ArgumentException("expr must be stloc");
			// ensure the variable is accessed only a single time
			if (method.GetSelfAndChildrenRecursive<ILExpression>().Count(e => e != expr && e.Operand == expr.Operand) != 1)
				return false;
			ILExpression parent;
			int pos;
			if (FindLoadInNext(next as ILExpression, (ILVariable)expr.Operand, out parent, out pos) == true) {
				parent.Arguments[pos] = expr.Arguments[0];
				return true;
			}
			return false;
		}

 public static void AddILRangesToInstruction(ILNode nodeToAddTo, ILNode prev, ILNode next, ILBlockBase block, ILNode removed)
 {
     Debug.Assert(nodeToAddTo == prev || nodeToAddTo == next || nodeToAddTo == block);
     if (nodeToAddTo != null) {
         if (nodeToAddTo == prev && prev.SafeToAddToEndILRanges) {
             removed.AddSelfAndChildrenRecursiveILRanges(prev.EndILRanges);
             return;
         }
         else if (nodeToAddTo != null && nodeToAddTo == next) {
             removed.AddSelfAndChildrenRecursiveILRanges(next.ILRanges);
             return;
         }
     }
     AddILRangesTryNextFirst(prev, next, block, removed);
 }

    public virtual ILNode Visit(ILNode node)
    {
        if (node == null)
            return node;

        var block = node as ILBlock;
        if (block != null)
            return VisitBlock(block);

        var basicBlock = node as ILBasicBlock;
        if (basicBlock != null)
            return VisitBasicBlock(basicBlock);

        var label = node as ILLabel;
        if (label != null)
            return VisitLabel(label);

        var tryCatchBlock = node as ILTryCatchBlock;
        if (tryCatchBlock != null)
            return VisitTryCatchBlock(tryCatchBlock);

        var expression = node as ILExpression;
        if (expression != null)
            return VisitExpression(expression);

        var whileLoop = node as ILWhileLoop;
        if (whileLoop != null)
            return VisitWhileLoop(whileLoop);

        var condition = node as ILCondition;
        if (condition != null)
            return VisitCondition(condition);

        var switchStatement = node as ILSwitch;
        if (switchStatement != null)
            return VisitSwitch(switchStatement);

        var fixedStatement = node as ILFixedStatement;
        if (fixedStatement != null)
            return VisitFixedStatement(fixedStatement);

        throw new NotSupportedException();
    }

        /// <summary>
        /// Get the first expression to be excecuted if the instruction pointer is at the start of the given node.
        /// Try blocks may not be entered in any way.  If possible, the try block is returned as the node to be executed.
        /// </summary>
        ILNode Enter(ILNode node, HashSet<ILNode> visitedNodes)
        {
            if (node == null)
                throw new ArgumentNullException();

            if (!visitedNodes.Add(node))
                return null;  // Infinite loop

            ILLabel label = node as ILLabel;
            if (label != null) {
                return Exit(label, visitedNodes);
            }

            ILExpression expr = node as ILExpression;
            if (expr != null) {
                if (expr.Code == ILCode.Br || expr.Code == ILCode.Leave) {
                    ILLabel target = (ILLabel)expr.Operand;
                    // Early exit - same try-block
                    if (GetParents(expr).OfType<ILTryCatchBlock>().FirstOrDefault() == GetParents(target).OfType<ILTryCatchBlock>().FirstOrDefault())
                        return Enter(target, visitedNodes);
                    // Make sure we are not entering any try-block
                    var srcTryBlocks = GetParents(expr).OfType<ILTryCatchBlock>().Reverse().ToList();
                    var dstTryBlocks = GetParents(target).OfType<ILTryCatchBlock>().Reverse().ToList();
                    // Skip blocks that we are already in
                    int i = 0;
                    while(i < srcTryBlocks.Count && i < dstTryBlocks.Count && srcTryBlocks[i] == dstTryBlocks[i]) i++;
                    if (i == dstTryBlocks.Count) {
                        return Enter(target, visitedNodes);
                    } else {
                        ILTryCatchBlock dstTryBlock = dstTryBlocks[i];
                        // Check that the goto points to the start
                        ILTryCatchBlock current = dstTryBlock;
                        while(current != null) {
                            foreach(ILNode n in current.TryBlock.Body) {
                                if (n is ILLabel) {
                                    if (n == target)
                                        return dstTryBlock;
                                } else if (!n.Match(ILCode.Nop)) {
                                    current = n as ILTryCatchBlock;
                                    break;
                                }
                            }
                        }
                        return null;
                    }
                } else if (expr.Code == ILCode.Nop) {
                    return Exit(expr, visitedNodes);
                } else if (expr.Code == ILCode.LoopOrSwitchBreak) {
                    ILNode breakBlock = GetParents(expr).First(n => n is ILWhileLoop || n is ILSwitch);
                    return Exit(breakBlock, new HashSet<ILNode>() { expr });
                } else if (expr.Code == ILCode.LoopContinue) {
                    ILNode continueBlock = GetParents(expr).First(n => n is ILWhileLoop);
                    return Enter(continueBlock, new HashSet<ILNode>() { expr });
                } else {
                    return expr;
                }
            }

            ILBlock block = node as ILBlock;
            if (block != null) {
                if (block.EntryGoto != null) {
                    return Enter(block.EntryGoto, visitedNodes);
                } else if (block.Body.Count > 0) {
                    return Enter(block.Body[0], visitedNodes);
                } else {
                    return Exit(block, visitedNodes);
                }
            }

            ILCondition cond = node as ILCondition;
            if (cond != null) {
                return cond.Condition;
            }

            ILWhileLoop loop = node as ILWhileLoop;
            if (loop != null) {
                if (loop.Condition != null) {
                    return loop.Condition;
                } else {
                    return Enter(loop.BodyBlock, visitedNodes);
                }
            }

            ILTryCatchBlock tryCatch = node as ILTryCatchBlock;
            if (tryCatch != null) {
                return tryCatch;
            }

            ILSwitch ilSwitch = node as ILSwitch;
            if (ilSwitch != null) {
                return ilSwitch.Condition;
            }

            throw new NotSupportedException(node.GetType().ToString());
        }

		/// <summary>Converts <see cref="ILNode"/> to <see cref="LNode"/> recursively.
		/// If the specified node is already an <see cref="LNode"/>, this method simply
		/// does a cast.</summary>
		public static LNode ToLNode(ILNode node)
		{
			return node is LNode ? (LNode)node : ToLNodeCore(node);
		}

		static LNode ToLNodeCore(ILNode node)
		{
			var attrs = VList<LNode>.Empty;
			for (int i = node.Min; i < -1; i++)
				attrs.Add(ToLNodeCore(node[i]));

			switch (node.Kind) {
				case LNodeKind.Id:
					return LNode.Id(attrs, node.Name, node.Range, node.Style);
				case LNodeKind.Literal:
					return LNode.Literal(attrs, node.Value, node.Range, node.Style);
				default:
					var args = VList<LNode>.Empty;
					for (int i = 0, max = node.Max; i <= max; i++)
						args.Add(ToLNodeCore(node[i]));
					var target = ToLNodeCore(node.Target);
					return LNode.Call(attrs, target, args, node.Range, node.Style);
			}
		}

 protected bool ContainsLabels(ILNode root)
 {
     var label = root.GetSelfAndChildrenRecursive<ILLabel>().FirstOrDefault();
     return label != null;
 }

        protected JSStatement TranslateStatement(ILNode node)
        {
            var translated = TranslateNode(node as dynamic);

            var statement = translated as JSStatement;
            if (statement == null) {
                var expression = (JSExpression)translated;

                if (expression != null)
                    statement = new JSExpressionStatement(expression);
                else
                    Console.Error.WriteLine("Warning: Null statement: {0}", node);
            }

            return statement;
        }

 /// <summary>
 /// Flattens all nested movable blocks, except the the top level 'node' argument
 /// </summary>
 void FlattenNestedMovableBlocks(ILNode node)
 {
     ILBlock block = node as ILBlock;
     if (block != null) {
         List<ILNode> flatBody = new List<ILNode>();
         if (block.EntryPoint != null) {
             flatBody.Add(new ILExpression(OpCodes.Br, block.EntryPoint));
             block.EntryPoint = null;
         }
         foreach (ILNode child in block.Body) {
             FlattenNestedMovableBlocks(child);
             if (child is ILMoveableBlock) {
                 flatBody.AddRange(((ILMoveableBlock)child).Body);
             } else {
                 flatBody.Add(child);
             }
         }
         block.Body = flatBody;
     } else if (node is ILExpression) {
         // Optimization - no need to check expressions
     } else if (node != null) {
         // Recursively find all ILBlocks
         foreach(ILNode child in node.GetChildren()) {
             FlattenNestedMovableBlocks(child);
         }
     }
 }

 bool MatchStateAssignment(ILNode stfld, out int stateID)
 {
     // stfld(StateMachine::<>1__state, ldloc(this), ldc.i4(stateId))
     stateID = 0;
     IField fieldRef;
     ILExpression target, val;
     if (stfld.Match(ILCode.Stfld, out fieldRef, out target, out val)) {
         return fieldRef.ResolveFieldWithinSameModule() == stateField
             && target.MatchThis()
             && val.Match(ILCode.Ldc_I4, out stateID);
     }
     return false;
 }

 public static void Info(string msg, ILNode node, params object[] o)
 {
     ErrorContext.Out.Info(msg,node, o);
 }

 public static void Warning(string msg, ILNode node, params object[] o)
 {
     ErrorContext.Out.Warning(msg, node, o);
 }

 /// <summary>
 /// Flattens all nested basic blocks, except the the top level 'node' argument
 /// </summary>
 void FlattenBasicBlocks(ILNode node)
 {
     ILBlock block = node as ILBlock;
     if (block != null) {
         List<ILNode> flatBody = new List<ILNode>();
         foreach (ILNode child in block.GetChildren()) {
             FlattenBasicBlocks(child);
             if (child is ILBasicBlock) {
                 flatBody.AddRange(child.GetChildren());
             } else {
                 flatBody.Add(child);
             }
         }
         block.EntryGoto = null;
         block.Body = flatBody;
     } else if (node is ILExpression) {
         // Optimization - no need to check expressions
     } else if (node != null) {
         // Recursively find all ILBlocks
         foreach(ILNode child in node.GetChildren()) {
             FlattenBasicBlocks(child);
         }
     }
 }