Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs	(revision 14328)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Configuration.cs	(revision 14392)
@@ -4,5 +4,5 @@
 namespace HeuristicLab.Algorithms.PushGP.Interpreter
 {
-    public class Configuration : Generators.Configuration
+    public class Configuration
     {
         public Configuration()
@@ -14,14 +14,20 @@
             this.IsNameStackEnabled = true;
 
-            this.EvalPushLimit = uint.MaxValue;
-            this.MaxPointsInProgram = uint.MaxValue;
-            this.MaxPointsInRandomExpression = uint.MaxValue;
+            this.EvalPushLimit = 1024;
+            this.MaxPointsInProgram = 4096;
+            this.MaxPointsInRandomExpression = 4096;
 
             this.TopLevelPushCode = true;
-            this.TopLevelPopCode = true;
+            this.TopLevelPopCode = false;
 
             this.RandomSeedMax = 30081;
             this.RandomSeedMin = 0;
             this.RandomSeed = null;
+
+            this.MinRandomInteger = -128;
+            this.MaxRandomInteger = 128;
+            this.MinRandomFloat = -128D;
+            this.MaxRandomFloat = 128D;
+            this.NewErcNameProbability = 0.5;
         }
 
@@ -32,5 +38,5 @@
         public bool IsNameStackEnabled { get; set; }
 
-        public IList<OpCode> AllowedInclassions { get; set; }
+        public IList<string> AllowedInstructions { get; set; }
 
         public IList<Expression> PredefinedExpressions { get; set; }
@@ -38,5 +44,5 @@
         /// <summary>
         /// This is the maximum allowed number of "executions" in a single top-level call to the interpreter.
-        /// The execution of a single Push inclassion counts as one execution, as does the processing of a single literal,
+        /// The execution of a single Push instruction counts as one execution, as does the processing of a single literal,
         /// as does the descent into one layer of parentheses (that is, the processing of the "(" counts as one execution).
         /// When this limit is exceeded the interpreter aborts immediately, leaving its stacks in the states they were in prior
@@ -48,11 +54,11 @@
         /// <summary>
         /// This is the maximum size of an item on the CODE stack, expressed as a number of points.
-        /// A point is an inclassion, a literal, or a pair of parentheses. Any inclassion that would cause this limit to be exceeded
-        /// should instead act as a NOOP, leaving all stacks in the states that they were in before the execution of the inclassion.
+        /// A point is an instruction, a literal, or a pair of parentheses. Any instruction that would cause this limit to be exceeded
+        /// should instead act as a NOOP, leaving all stacks in the states that they were in before the execution of the instruction.
         /// </summary>
         public uint MaxPointsInProgram { get; set; }
 
         /// <summary>
-        /// The maximum number of points in an expression produced by the CODE.RAND inclassion.
+        /// The maximum number of points in an expression produced by the CODE.RAND instruction.
         /// </summary>
         public uint MaxPointsInRandomExpression { get; set; }
@@ -69,4 +75,31 @@
         public bool TopLevelPopCode { get; set; }
 
+        /// <summary>
+        /// The minimum INTEGER that will be produced as an ephemeral random INTEGER constant or from a call to INTEGER.RAND.
+        /// </summary>
+        public int MinRandomInteger { get; set; }
+
+        /// <summary>
+        /// The maximum INTEGER that will be produced as an ephemeral random INTEGER constant or from a call to INTEGER.RAND.
+        /// </summary>
+        public int MaxRandomInteger { get; set; }
+
+        /// <summary>
+        /// The minimum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
+        /// </summary>
+        public double MinRandomFloat { get; set; }
+
+        /// <summary>
+        /// The maximum FLOAT that will be produced as an ephemeral random FLOAT constant or from a call to FLOAT.RAND.
+        /// </summary>
+        public double MaxRandomFloat { get; set; }
+
+        /// <summary>
+        /// The probability that the selection of the ephemeral
+        /// random NAME constant for inclusion in randomly generated code will produce a new name
+        /// (rather than a name that was previously generated).
+        /// </summary>
+        public double NewErcNameProbability { get; set; }
+
         public ushort RandomSeedMax { get; set; }
         public ushort RandomSeedMin { get; set; }
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/IInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/IInterpreter.cs	(revision 14328)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/IInterpreter.cs	(revision 14392)
@@ -3,4 +3,5 @@
 using System.Threading.Tasks;
 using HeuristicLab.Algorithms.PushGP.Expressions;
+using HeuristicLab.Algorithms.PushGP.Generators;
 using HeuristicLab.Algorithms.PushGP.Stack;
 
@@ -15,6 +16,11 @@
         IStack<long> IntegerStack { get; }
         IStack<double> FloatStack { get; }
+        IDictionary<string, Expression> CustomExpressions { get; }
 
-        IDictionary<string, Expression> CustomExpressions { get; }
+        Configuration Configuration { get; }
+
+        CodeGenerator CodeGenerator { get; }
+
+        bool IsNameQuoteFlagSet { get; set; }
 
         void Interpret(string code);
@@ -22,5 +28,5 @@
         void Interpret(Expression program);
         Task InterpretAsync(Expression program, bool paused = false, CancellationToken token = default(CancellationToken));
-        Task AbortAndReset();
+        Task AbortAndResetAsync();
         Task AbortAsync();
         Task PauseAsync();
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Interpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/Interpreter.cs	(revision 14328)
+++ 	(revision )
@@ -1,241 +1,0 @@
-﻿using System;
-using System.Collections.Generic;
-using System.Threading;
-using System.Threading.Tasks;
-using HeuristicLab.Algorithms.PushGP.Expressions;
-using HeuristicLab.Algorithms.PushGP.Stack;
-
-namespace HeuristicLab.Algorithms.PushGP.Interpreter
-{
-    public class PushGPInterpreter : IInterpreter
-    {
-        private Task currentTask;
-
-        public PushGPInterpreter(Configuration config = null)
-        {
-            this.Configuration = config ?? new Configuration();
-
-            this.CodeStack = new PushGPStack<Expression>(128);
-            this.ExecStack = new PushGPStack<Expression>(128);
-            this.NameStack = new PushGPStack<string>(16);
-            this.BooleanStack = new PushGPStack<bool>(16);
-            this.IntegerStack = new PushGPStack<long>(16);
-            this.FloatStack = new PushGPStack<double>(16);
-
-            this.CustomExpressions = new Dictionary<string, Expression>();
-        }
-
-        public Configuration Configuration { get; private set; }
-
-        public bool IsPaused { get; private set; }
-        public bool IsAborted { get; private set; }
-        public bool IsRunning { get { return this.ExecStack.Count > 0 && !IsPaused && !IsAborted; } }
-        public bool IsCompleted { get { return this.ExecStack.Count == 0; } }
-        public bool CanStep { get { return !IsCompleted && !IsAborted && IsPaused; } }
-
-        public IStack<Expression> CodeStack { get; private set; }
-        public IStack<Expression> ExecStack { get; private set; }
-        public IStack<string> NameStack { get; private set; }
-        public IStack<bool> BooleanStack { get; private set; }
-        public IStack<long> IntegerStack { get; private set; }
-        public IStack<double> FloatStack { get; private set; }
-
-        public IDictionary<string, Expression> CustomExpressions { get; private set; }
-
-        public void Reset()
-        {
-            this.IsAborted = false;
-            this.IsPaused = false;
-            this.currentTask = null;
-
-            this.Clear();
-        }
-
-        public void Clear()
-        {
-            this.ExecStack.Clear();
-            this.CodeStack.Clear();
-            this.NameStack.Clear();
-            this.BooleanStack.Clear();
-            this.IntegerStack.Clear();
-            this.FloatStack.Clear();
-
-            this.CustomExpressions.Clear();
-        }
-
-        public void Interpret(string code)
-        {
-            var program = Encode(code);
-            this.Interpret(program);
-        }
-
-        public Task InterpretAsync(string code, bool paused = false, CancellationToken token = default(CancellationToken))
-        {
-            var program = Encode(code);
-
-            this.currentTask = this.InterpretAsync(program, paused, token);
-
-            return currentTask;
-        }
-
-        public Task InterpretAsync(Expression program, bool paused = false, CancellationToken token = default(CancellationToken))
-        {
-            this.IsPaused = paused;
-            this.currentTask = Task.Run(() => this.Interpret(program), token);
-
-            return currentTask;
-        }
-
-        public void Interpret(Expression program)
-        {
-            this.IsAborted = false;
-
-            /* Push top expression so the loop is able to enter
-             * If the top expression is a single statement then the loop has nothing to do
-             * Otherwise the expand expression will be evaluated and pushes code onto the EXEC stack */
-            this.ExecStack.Push(program);
-            this.CodeStack.Push(program);
-
-            // run top expression
-            this.ExecStack.Pop().Eval(this);
-
-            this.Interpret();
-        }
-
-        private void Interpret()
-        {
-            if (!IsRunning)
-            {
-                return;
-            }
-
-            while (IsRunning)
-            {
-                this.DoStep();
-            }
-
-            if (this.Configuration.TopLevelPushCode)
-            {
-                this.CodeStack.Pop();
-            }
-        }
-
-        private void DoStep()
-        {
-            var expression = this.ExecStack.Pop();
-
-            if (!expression.IsCodeOp)
-            {
-                this.CodeStack.Push(expression);
-            }
-
-            expression.Eval(this);
-
-            if (!expression.IsCodeOp)
-            {
-                CodeStack.Pop();
-            }
-        }
-
-        private Task InterpreteAsync()
-        {
-            this.currentTask = Task.Run(() => this.Interpret());
-
-            return this.currentTask;
-        }
-
-        public async Task AbortAsync()
-        {
-            if (this.IsAborted || this.IsCompleted)
-                return;
-
-            this.IsAborted = true;
-
-            if (this.currentTask != null)
-            {
-                await this.currentTask;
-            }
-        }
-
-        public async Task AbortAndReset()
-        {
-            await this.AbortAsync();
-            this.Reset();
-        }
-
-        public async Task PauseAsync()
-        {
-            if (this.IsPaused || this.IsCompleted)
-                return;
-
-            this.IsPaused = true;
-
-            if (this.currentTask != null)
-            {
-                await this.currentTask;
-            }
-        }
-
-        public Task ResumeAsync()
-        {
-            if (this.IsPaused || !this.IsAborted)
-            {
-                this.IsPaused = false;
-                return this.InterpreteAsync();
-            }
-
-            return this.currentTask;
-        }
-
-        public void Step()
-        {
-            if (CanStep)
-            {
-                DoStep();
-
-                if (IsCompleted && this.Configuration.TopLevelPopCode)
-                {
-                    this.CodeStack.Pop();
-                }
-            }
-        }
-
-        public static Expression Encode(string code)
-        {
-            return Parser.Parse(code);
-        }
-
-        public static Task<Expression> EncodeAsync(string code, CancellationToken token = default(CancellationToken))
-        {
-            return Task.Run(() => Encode(code), token);
-        }
-
-        public static string Decode(Expression expression)
-        {
-            return string.Concat(expression.ToString());
-        }
-
-        public static Task<string> DecodeAsync(Expression expression, CancellationToken token = default(CancellationToken))
-        {
-            return Task.Run(() => Decode(expression), token);
-        }
-
-        public void PrintStacks()
-        {
-            this.PrintStack("EXEC", this.ExecStack);
-            this.PrintStack("CODE", this.CodeStack);
-            this.PrintStack("NAME", this.NameStack);
-            this.PrintStack("BOOLEAN", this.BooleanStack);
-            this.PrintStack("FLOAT", this.FloatStack);
-            this.PrintStack("INTEGER", this.IntegerStack);
-        }
-
-        private void PrintStack<T>(string name, IStack<T> stack)
-        {
-            Console.WriteLine(string.Format(
-                "--- {0} ---\n{1}\n---------------------------------------------------",
-                name,
-                stack));
-        }
-    }
-}
Index: branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs
===================================================================
--- branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs	(revision 14392)
+++ branches/PushGP/HeuristicLab.Algorithms.PushGP/HeuristicLab.Algorithms.PushGP/Interpreter/PushGPInterpreter.cs	(revision 14392)
@@ -0,0 +1,247 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using HeuristicLab.Algorithms.PushGP.Expressions;
+using HeuristicLab.Algorithms.PushGP.Generators;
+using HeuristicLab.Algorithms.PushGP.Stack;
+
+namespace HeuristicLab.Algorithms.PushGP.Interpreter
+{
+    public class PushGPInterpreter : IInterpreter
+    {
+        private Task currentTask;
+
+
+        public PushGPInterpreter(Configuration config = null)
+        {
+            this.Configuration = config ?? new Configuration();
+
+            this.CodeStack = new PushGPStack<Expression>(128);
+            this.ExecStack = new PushGPStack<Expression>(128);
+            this.NameStack = new PushGPStack<string>(16);
+            this.BooleanStack = new PushGPStack<bool>(16);
+            this.IntegerStack = new PushGPStack<long>(16);
+            this.FloatStack = new PushGPStack<double>(16);
+
+            this.CustomExpressions = new Dictionary<string, Expression>();
+
+            this.CodeGenerator = new CodeGenerator(this);
+        }
+
+        public Configuration Configuration { get; private set; }
+
+        public int ExecCounter { get; private set; }
+        public bool IsPaused { get; private set; }
+        public bool IsAborted { get; private set; }
+        public bool IsRunning { get { return this.ExecStack.Count > 0 && !IsPaused && !IsAborted && ExecCounter < Configuration.EvalPushLimit; } }
+        public bool IsCompleted { get { return this.ExecStack.Count == 0; } }
+        public bool CanStep { get { return !IsCompleted && !IsAborted && IsPaused; } }
+
+        public IStack<Expression> CodeStack { get; private set; }
+        public IStack<Expression> ExecStack { get; private set; }
+        public IStack<string> NameStack { get; private set; }
+        public IStack<bool> BooleanStack { get; private set; }
+        public IStack<long> IntegerStack { get; private set; }
+        public IStack<double> FloatStack { get; private set; }
+
+        public IDictionary<string, Expression> CustomExpressions { get; private set; }
+
+        public CodeGenerator CodeGenerator { get; private set; }
+
+        public bool IsNameQuoteFlagSet { get; set; }
+
+        public void Reset()
+        {
+            this.IsAborted = false;
+            this.IsPaused = false;
+            this.currentTask = null;
+
+            this.Clear();
+        }
+
+        public void Clear()
+        {
+            this.ExecCounter = 0;
+
+            this.ExecStack.Clear();
+            this.CodeStack.Clear();
+            this.NameStack.Clear();
+            this.BooleanStack.Clear();
+            this.IntegerStack.Clear();
+            this.FloatStack.Clear();
+
+            this.CustomExpressions.Clear();
+        }
+
+        public void Interpret(string code)
+        {
+            var program = Encode(code);
+            this.Interpret(program);
+        }
+
+        public Task InterpretAsync(string code, bool paused = false, CancellationToken token = default(CancellationToken))
+        {
+            var program = Encode(code);
+
+            this.currentTask = this.InterpretAsync(program, paused, token);
+
+            return currentTask;
+        }
+
+        public Task InterpretAsync(Expression program, bool paused = false, CancellationToken token = default(CancellationToken))
+        {
+            this.IsPaused = paused;
+            this.currentTask = Task.Run(() => this.Interpret(program), token);
+
+            return currentTask;
+        }
+
+        public void Interpret(Expression program)
+        {
+            /* Push top expression so the loop is able to enter
+             * If the top expression is a single statement then the loop has nothing to do
+             * Otherwise the expand expression will be evaluated and pushes code onto the EXEC stack */
+            this.ExecStack.Push(program);
+
+            if (this.Configuration.TopLevelPushCode)
+            {
+                this.CodeStack.Insert(0, program);
+            }
+
+            // run top expression
+            this.ExecStack.Pop().Eval(this);
+
+            this.Interpret();
+        }
+
+        private void Interpret()
+        {
+            while (this.IsRunning)
+            {
+                this.DoStep();
+                this.ExecCounter++;
+            }
+
+            this.Finally();
+        }
+
+        private void Finally()
+        {
+            if (this.IsCompleted && this.Configuration.TopLevelPopCode && this.CodeStack.Count > 0)
+            {
+                this.CodeStack.Pop();
+            }
+        }
+
+        private void DoStep()
+        {
+            this.ExecStack.Pop().Eval(this);
+        }
+
+        private Task InterpreteAsync()
+        {
+            this.currentTask = Task.Run(() => this.Interpret());
+
+            return this.currentTask;
+        }
+
+        public async Task AbortAsync()
+        {
+            if (this.IsAborted || this.IsCompleted)
+                return;
+
+            this.IsAborted = true;
+
+            if (this.currentTask != null)
+            {
+                await this.currentTask;
+            }
+        }
+
+        public async Task AbortAndResetAsync()
+        {
+            await this.AbortAsync();
+            this.Reset();
+        }
+
+        public async Task PauseAsync()
+        {
+            if (this.IsPaused || this.IsCompleted)
+                return;
+
+            this.IsPaused = true;
+
+            if (this.currentTask != null)
+            {
+                await this.currentTask;
+            }
+        }
+
+        public Task ResumeAsync()
+        {
+            if (this.IsPaused || !this.IsAborted)
+            {
+                this.IsPaused = false;
+                return this.InterpreteAsync();
+            }
+
+            return this.currentTask;
+        }
+
+        public void Step()
+        {
+            if (this.CanStep)
+            {
+                this.DoStep();
+                this.Finally();
+            }
+        }
+
+        public void Step(int count)
+        {
+            for (var i = 0; i < count; i++)
+            {
+                this.Step();
+            }
+        }
+
+        public static Expression Encode(string code)
+        {
+            return Parser.Parse(code);
+        }
+
+        public static Task<Expression> EncodeAsync(string code, CancellationToken token = default(CancellationToken))
+        {
+            return Task.Run(() => Encode(code), token);
+        }
+
+        public static string Decode(Expression expression)
+        {
+            return string.Concat(expression.ToString());
+        }
+
+        public static Task<string> DecodeAsync(Expression expression, CancellationToken token = default(CancellationToken))
+        {
+            return Task.Run(() => Decode(expression), token);
+        }
+
+        public void PrintStacks()
+        {
+            this.PrintStack("EXEC", this.ExecStack);
+            this.PrintStack("CODE", this.CodeStack);
+            this.PrintStack("NAME", this.NameStack);
+            this.PrintStack("BOOLEAN", this.BooleanStack);
+            this.PrintStack("FLOAT", this.FloatStack);
+            this.PrintStack("INTEGER", this.IntegerStack);
+        }
+
+        private void PrintStack<T>(string name, IStack<T> stack)
+        {
+            Console.WriteLine(string.Format(
+                "--- {0} ---\n{1}\n---------------------------------------------------",
+                name,
+                stack));
+        }
+    }
+}
