/// <summary>
        /// Applies the transformation
        /// </summary>
        /// <returns>The transformed item.</returns>
        /// <param name="item">The item to visit.</param>
        public ASTItem Transform(ASTItem item)
        {
            var stm = item as AST.ForStatement;

            if (stm == null)
            {
                return(item);
            }

            if (m_processed.Contains(stm))
            {
                return(item);
            }
            m_processed.Add(stm);

            Tuple <int, int, int> loopedges = null;

            try
            {
                loopedges = stm.GetStaticForLoopValues();
            }
            catch
            {
                return(item);
            }

            var incr = loopedges.Item3;

            if (incr == 1)
            {
                return(item);
            }

            var tmp = State.RegisterTemporaryVariable(Method, stm.LoopIndex.CecilType);

            State.TypeLookup[tmp] = VHDLTypes.INTEGER;

            // Find the first expression, so we can inject the assignment before it
            var firstexp = stm.LoopBody.All().OfType <Expression>().First();

            // Replace all the references
            foreach (var x in stm.All().OfType <Expression>())
            {
                var target = x.GetTarget();
                if (target == stm.LoopIndex)
                {
                    x.SetTarget(tmp);
                }
            }

            var exp = firstexp.SourceExpression;

            // Inject the assignment
            var nstm = new ExpressionStatement()
            {
                Expression = new AssignmentExpression()
                {
                    Left = new IdentifierExpression()
                    {
                        Name             = tmp.Name,
                        Target           = tmp,
                        SourceExpression = exp,
                        SourceResultType = tmp.CecilType
                    },
                    Operator = ICSharpCode.Decompiler.CSharp.Syntax.AssignmentOperatorType.Assign,
                    Right    = new BinaryOperatorExpression()
                    {
                        Left = new IdentifierExpression()
                        {
                            Name             = stm.LoopIndex.Name,
                            Target           = stm.LoopIndex,
                            SourceExpression = exp,
                            SourceResultType = stm.LoopIndex.CecilType
                        },
                        Operator = ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.Multiply,
                        Right    = new PrimitiveExpression()
                        {
                            Value            = incr,
                            SourceResultType = tmp.CecilType,
                            SourceExpression = exp,
                        },
                        SourceExpression = exp,
                        SourceResultType = tmp.CecilType
                    },
                    SourceExpression = exp,
                    SourceResultType = tmp.CecilType
                }
            };

            nstm.UpdateParents();
            foreach (var x in nstm.All().OfType <Expression>())
            {
                State.TypeLookup[x] = VHDLTypes.INTEGER;
            }

            stm.LoopBody.PrependStatement(nstm);

            //Do not fix again
            stm.Increment = new AssignmentExpression(
                new IdentifierExpression(stm.LoopIndex),
                new BinaryOperatorExpression(
                    new IdentifierExpression(stm.LoopIndex),
                    ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.Add,
                    new PrimitiveExpression(1, tmp.CecilType)
                    )
            {
                SourceResultType = tmp.CecilType
            }
                )
            {
                Parent = stm, SourceResultType = tmp.CecilType
            };

            stm.Condition = new BinaryOperatorExpression(
                new IdentifierExpression(stm.LoopIndex),
                ICSharpCode.Decompiler.CSharp.Syntax.BinaryOperatorType.LessThan,
                new PrimitiveExpression(loopedges.Item2 / loopedges.Item3, tmp.CecilType.Module.ImportReference(typeof(int)))
                )
            {
                Parent           = stm,
                SourceResultType = tmp.CecilType.Module.ImportReference(typeof(bool))
            };

            return(nstm);
        }